const std = @import("std");
const assert = std.debug.assert;
const codegen = @import("../../codegen.zig");
const link = @import("../../link.zig");
const log = std.log.scoped(.codegen);
const tracking_log = std.log.scoped(.tracking);
const verbose_tracking_log = std.log.scoped(.verbose_tracking);
const wip_mir_log = std.log.scoped(.wip_mir);
const Writer = std.Io.Writer;

const Air = @import("../../Air.zig");
const Allocator = std.mem.Allocator;
const Emit = @import("Emit.zig");
const Lower = @import("Lower.zig");
const Mir = @import("Mir.zig");
const Zcu = @import("../../Zcu.zig");
const Module = @import("../../Package/Module.zig");
const InternPool = @import("../../InternPool.zig");
const Type = @import("../../Type.zig");
const Value = @import("../../Value.zig");

const abi = @import("abi.zig");
const bits = @import("bits.zig");
const encoder = @import("encoder.zig");

const Condition = bits.Condition;
const Immediate = bits.Immediate;
const Memory = bits.Memory;
const Register = bits.Register;
const RegisterManager = abi.RegisterManager;
const RegisterLock = RegisterManager.RegisterLock;
const FrameIndex = bits.FrameIndex;

const InnerError = codegen.CodeGenError || error{OutOfRegisters};

pub fn legalizeFeatures(_: *const std.Target) *const Air.Legalize.Features {
    return comptime &.initMany(&.{
        .scalarize_mul_sat,
        .scalarize_div_floor,
        .scalarize_mod,
        .scalarize_add_with_overflow,
        .scalarize_sub_with_overflow,
        .scalarize_mul_with_overflow,
        .scalarize_shl_with_overflow,
        .scalarize_shr,
        .scalarize_shr_exact,
        .scalarize_shl,
        .scalarize_shl_exact,
        .scalarize_shl_sat,
        .scalarize_bitcast,
        .scalarize_ctz,
        .scalarize_popcount,
        .scalarize_byte_swap,
        .scalarize_bit_reverse,
        .scalarize_cmp_vector,
        .scalarize_cmp_vector_optimized,
        .scalarize_shuffle_one,
        .scalarize_shuffle_two,
        .scalarize_select,

        //.unsplat_shift_rhs,
        .reduce_one_elem_to_bitcast,
        .splat_one_elem_to_bitcast,

        .expand_intcast_safe,
        .expand_int_from_float_safe,
        .expand_int_from_float_optimized_safe,
        .expand_add_safe,
        .expand_sub_safe,
        .expand_mul_safe,

        .expand_packed_load,
        .expand_packed_store,
        .expand_packed_struct_field_val,
        .expand_packed_aggregate_init,
    });
}

/// Set this to `false` to uncover Sema OPV bugs.
/// https://github.com/ziglang/zig/issues/22419
const hack_around_sema_opv_bugs = true;

const err_ret_trace_index: Air.Inst.Index = @enumFromInt(std.math.maxInt(u32));

gpa: Allocator,
pt: Zcu.PerThread,
air: Air,
liveness: Air.Liveness,
target: *const std.Target,
owner: union(enum) {
    nav_index: InternPool.Nav.Index,
    lazy_sym: link.File.LazySymbol,
},
inline_func: InternPool.Index,
mod: *Module,
args: []MCValue,
va_info: union {
    sysv: struct {
        gp_count: u32,
        fp_count: u32,
        overflow_arg_area: bits.FrameAddr,
        reg_save_area: bits.FrameAddr,
    },
    win64: struct {},
},
ret_mcv: InstTracking,
err_ret_trace_reg: Register,
fn_type: Type,
src_loc: Zcu.LazySrcLoc,

eflags_inst: ?Air.Inst.Index = null,

/// MIR Instructions
mir_instructions: std.MultiArrayList(Mir.Inst) = .empty,
/// MIR extra data
mir_extra: std.ArrayList(u32) = .empty,
mir_string_bytes: std.ArrayList(u8) = .empty,
mir_strings: std.HashMapUnmanaged(
    u32,
    void,
    std.hash_map.StringIndexContext,
    std.hash_map.default_max_load_percentage,
) = .empty,
mir_locals: std.ArrayList(Mir.Local) = .empty,
mir_table: std.ArrayList(Mir.Inst.Index) = .empty,

/// The value is an offset into the `Function` `code` from the beginning.
/// To perform the reloc, write 32-bit signed little-endian integer
/// which is a relative jump, based on the address following the reloc.
epilogue_relocs: std.ArrayList(Mir.Inst.Index) = .empty,

reused_operands: std.StaticBitSet(Air.Liveness.bpi - 1) = undefined,
inst_tracking: InstTrackingMap = .empty,

// Key is the block instruction
blocks: std.AutoHashMapUnmanaged(Air.Inst.Index, BlockData) = .empty,

register_manager: RegisterManager = .{},

/// Generation of the current scope, increments by 1 for every entered scope.
scope_generation: u32 = 0,

frame_allocs: std.MultiArrayList(FrameAlloc) = .empty,
free_frame_indices: std.AutoArrayHashMapUnmanaged(FrameIndex, void) = .empty,
frame_locs: std.MultiArrayList(Mir.FrameLoc) = .empty,

loops: std.AutoHashMapUnmanaged(Air.Inst.Index, struct {
    /// The state to restore before branching.
    state: State,
    /// The branch target.
    target: Mir.Inst.Index,
}) = .empty,
loop_switches: std.AutoHashMapUnmanaged(Air.Inst.Index, struct {
    start: u31,
    len: u11,
    min: Value,
    else_relocs: union(enum) {
        @"unreachable",
        forward: std.ArrayList(Mir.Inst.Index),
        backward: Mir.Inst.Index,
    },
}) = .empty,

next_temp_index: Temp.Index = @enumFromInt(0),
temp_type: [Temp.Index.max]Type = undefined,

const MaskInfo = packed struct {
    kind: enum(u1) { sign, all },
    inverted: bool = false,
    scalar: Memory.Size,
};

pub const MCValue = union(enum) {
    /// No runtime bits. `void` types, empty structs, u0, enums with 1 tag, etc.
    /// TODO Look into deleting this tag and using `dead` instead, since every use
    /// of MCValue.none should be instead looking at the type and noticing it is 0 bits.
    none,
    /// Control flow will not allow this value to be observed.
    unreach,
    /// No more references to this value remain.
    /// The payload is the value of scope_generation at the point where the death occurred
    dead: u32,
    /// The value is undefined.
    undef,
    /// A pointer-sized integer that fits in a register.
    /// If the type is a pointer, this is the pointer address in virtual address space.
    immediate: u64,
    /// The value resides in the EFLAGS register.
    eflags: Condition,
    /// The value is in a register.
    register: Register,
    /// The value is split across two registers.
    register_pair: [2]Register,
    /// The value is split across three registers.
    register_triple: [3]Register,
    /// The value is split across four registers.
    register_quadruple: [4]Register,
    /// The value is a constant offset from the value in a register.
    register_offset: bits.RegisterOffset,
    /// The value is a tuple { wrapped, overflow } where wrapped value is stored in the GP register.
    register_overflow: struct { reg: Register, eflags: Condition },
    /// The value is a bool vector stored in a vector register with a different scalar type.
    register_mask: struct { reg: Register, info: MaskInfo },
    /// The value is in memory at a hard-coded address.
    /// If the type is a pointer, it means the pointer address is stored at this memory location.
    memory: u64,
    /// The value is in memory at a constant offset from the address in a register.
    indirect: bits.RegisterOffset,
    indirect_load_frame: bits.FrameAddr,
    /// The value stored at an offset from a frame index
    /// Payload is a frame address.
    load_frame: bits.FrameAddr,
    /// The address of an offset from a frame index
    /// Payload is a frame address.
    lea_frame: bits.FrameAddr,
    load_nav: InternPool.Nav.Index,
    lea_nav: InternPool.Nav.Index,
    load_uav: InternPool.Key.Ptr.BaseAddr.Uav,
    lea_uav: InternPool.Key.Ptr.BaseAddr.Uav,
    load_lazy_sym: link.File.LazySymbol,
    lea_lazy_sym: link.File.LazySymbol,
    load_extern_func: Mir.NullTerminatedString,
    lea_extern_func: Mir.NullTerminatedString,
    /// Supports integer_per_element abi
    elementwise_args: packed struct { regs: u3, frame_off: i29, frame_index: FrameIndex },
    /// This indicates that we have already allocated a frame index for this instruction,
    /// but it has not been spilled there yet in the current control flow.
    /// Payload is a frame index.
    reserved_frame: FrameIndex,
    air_ref: Air.Inst.Ref,

    fn isModifiable(mcv: MCValue) bool {
        return switch (mcv) {
            .none,
            .unreach,
            .dead,
            .undef,
            .immediate,
            .register_offset,
            .register_mask,
            .eflags,
            .register_overflow,
            .indirect_load_frame,
            .lea_frame,
            .lea_nav,
            .load_uav,
            .lea_uav,
            .load_lazy_sym,
            .lea_lazy_sym,
            .lea_extern_func,
            .load_extern_func,
            .elementwise_args,
            .reserved_frame,
            .air_ref,
            => false,
            .register,
            .register_pair,
            .register_triple,
            .register_quadruple,
            .memory,
            .indirect,
            .load_nav,
            => true,
            .load_frame => |frame_addr| !frame_addr.index.isNamed(),
        };
    }

    // hack around linker relocation bugs
    fn isBase(mcv: MCValue) bool {
        return switch (mcv) {
            .memory, .indirect, .load_frame => true,
            else => false,
        };
    }

    fn isMemory(mcv: MCValue) bool {
        return switch (mcv) {
            .memory,
            .indirect,
            .load_frame,
            .load_nav,
            .load_uav,
            .load_lazy_sym,
            .load_extern_func,
            => true,
            else => false,
        };
    }

    fn isImmediate(mcv: MCValue) bool {
        return switch (mcv) {
            .immediate => true,
            else => false,
        };
    }

    fn isRegister(mcv: MCValue) bool {
        return switch (mcv) {
            .register => true,
            .register_offset => |reg_off| return reg_off.off == 0,
            else => false,
        };
    }

    fn isRegisterOffset(mcv: MCValue) bool {
        return switch (mcv) {
            .register, .register_offset => true,
            else => false,
        };
    }

    fn getReg(mcv: MCValue) ?Register {
        return switch (mcv) {
            .register => |reg| reg,
            .register_offset, .indirect => |ro| ro.reg,
            .register_overflow => |ro| ro.reg,
            .register_mask => |rm| rm.reg,
            else => null,
        };
    }

    fn getRegs(mcv: *const MCValue) []const Register {
        return switch (mcv.*) {
            .register => |*reg| reg[0..1],
            inline .register_pair,
            .register_triple,
            .register_quadruple,
            => |*regs| regs,
            inline .register_offset,
            .indirect,
            .register_overflow,
            .register_mask,
            => |*pl| (&pl.reg)[0..1],
            else => &.{},
        };
    }

    fn getCondition(mcv: MCValue) ?Condition {
        return switch (mcv) {
            .eflags => |cc| cc,
            .register_overflow => |reg_ov| reg_ov.eflags,
            else => null,
        };
    }

    fn isAddress(mcv: MCValue) bool {
        return switch (mcv) {
            .immediate, .register, .register_offset, .lea_frame => true,
            else => false,
        };
    }

    fn address(mcv: MCValue) MCValue {
        return switch (mcv) {
            .none => .none,
            .unreach,
            .dead,
            .undef,
            .immediate,
            .eflags,
            .register,
            .register_pair,
            .register_triple,
            .register_quadruple,
            .register_offset,
            .register_overflow,
            .register_mask,
            .lea_frame,
            .lea_nav,
            .lea_uav,
            .lea_lazy_sym,
            .lea_extern_func,
            .elementwise_args,
            .reserved_frame,
            .air_ref,
            => unreachable, // not in memory
            .memory => |addr| .{ .immediate = addr },
            .indirect => |reg_off| switch (reg_off.off) {
                0 => .{ .register = reg_off.reg },
                else => .{ .register_offset = reg_off },
            },
            .indirect_load_frame => |frame_addr| .{ .load_frame = frame_addr },
            .load_frame => |frame_addr| .{ .lea_frame = frame_addr },
            .load_nav => |nav| .{ .lea_nav = nav },
            .load_uav => |uav| .{ .lea_uav = uav },
            .load_lazy_sym => |lazy_sym| .{ .lea_lazy_sym = lazy_sym },
            .load_extern_func => |extern_func| .{ .lea_extern_func = extern_func },
        };
    }

    fn deref(mcv: MCValue) MCValue {
        return switch (mcv) {
            .none => .none,
            .unreach,
            .dead,
            .undef,
            .eflags,
            .register_pair,
            .register_triple,
            .register_quadruple,
            .register_overflow,
            .register_mask,
            .memory,
            .indirect,
            .indirect_load_frame,
            .load_nav,
            .load_uav,
            .load_lazy_sym,
            .load_extern_func,
            .elementwise_args,
            .reserved_frame,
            .air_ref,
            => unreachable, // not dereferenceable
            .immediate => |addr| .{ .memory = addr },
            .register => |reg| .{ .indirect = .{ .reg = reg } },
            .register_offset => |reg_off| .{ .indirect = reg_off },
            .load_frame => |frame_addr| .{ .indirect_load_frame = frame_addr },
            .lea_frame => |frame_addr| .{ .load_frame = frame_addr },
            .lea_nav => |nav| .{ .load_nav = nav },
            .lea_uav => |uav| .{ .load_uav = uav },
            .lea_lazy_sym => |lazy_sym| .{ .load_lazy_sym = lazy_sym },
            .lea_extern_func => |extern_func| .{ .load_extern_func = extern_func },
        };
    }

    fn offset(mcv: MCValue, off: i32) MCValue {
        return switch (mcv) {
            .none => .none,
            .unreach,
            .dead,
            .undef,
            .elementwise_args,
            .reserved_frame,
            .air_ref,
            => unreachable, // not valid
            .eflags,
            .register_pair,
            .register_triple,
            .register_quadruple,
            .register_overflow,
            .register_mask,
            .memory,
            .indirect,
            .indirect_load_frame,
            .load_frame,
            .load_nav,
            .lea_nav,
            .load_uav,
            .lea_uav,
            .load_lazy_sym,
            .lea_lazy_sym,
            .load_extern_func,
            .lea_extern_func,
            => switch (off) {
                0 => mcv,
                else => unreachable, // not offsettable
            },
            .immediate => |imm| .{ .immediate = @bitCast(@as(i64, @bitCast(imm)) +% off) },
            .register => |reg| .{ .register_offset = .{ .reg = reg, .off = off } },
            .register_offset => |reg_off| .{
                .register_offset = .{ .reg = reg_off.reg, .off = reg_off.off + off },
            },
            .lea_frame => |frame_addr| .{
                .lea_frame = .{ .index = frame_addr.index, .off = frame_addr.off + off },
            },
        };
    }

    fn mem(mcv: MCValue, function: *CodeGen, mod_rm: Memory.Mod.Rm) !Memory {
        return switch (mcv) {
            .none => .{ .mod = .{ .rm = mod_rm } },
            .unreach,
            .dead,
            .undef,
            .immediate,
            .eflags,
            .register,
            .register_pair,
            .register_triple,
            .register_quadruple,
            .register_offset,
            .register_overflow,
            .register_mask,
            .indirect_load_frame,
            .lea_frame,
            .elementwise_args,
            .reserved_frame,
            .lea_nav,
            .lea_uav,
            .lea_lazy_sym,
            .lea_extern_func,
            => unreachable,
            .memory => |addr| if (std.math.cast(i32, @as(i64, @bitCast(addr)))) |small_addr| .{
                .base = .{ .reg = .ds },
                .mod = .{ .rm = .{
                    .size = mod_rm.size,
                    .index = mod_rm.index,
                    .scale = mod_rm.scale,
                    .disp = small_addr + mod_rm.disp,
                } },
            } else .{ .base = .{ .reg = .ds }, .mod = .{ .off = addr } },
            .indirect => |reg_off| .{
                .base = .{ .reg = reg_off.reg.toSize(.ptr, function.target) },
                .mod = .{ .rm = .{
                    .size = mod_rm.size,
                    .index = mod_rm.index,
                    .scale = mod_rm.scale,
                    .disp = reg_off.off + mod_rm.disp,
                } },
            },
            .load_frame => |frame_addr| .{
                .base = .{ .frame = frame_addr.index },
                .mod = .{ .rm = .{
                    .size = mod_rm.size,
                    .index = mod_rm.index,
                    .scale = mod_rm.scale,
                    .disp = frame_addr.off + mod_rm.disp,
                } },
            },
            .load_nav => |nav| .{ .base = .{ .nav = nav }, .mod = .{ .rm = mod_rm } },
            .load_uav => |uav| .{ .base = .{ .uav = uav }, .mod = .{ .rm = mod_rm } },
            .load_lazy_sym => |lazy_sym| .{ .base = .{ .lazy_sym = lazy_sym }, .mod = .{ .rm = mod_rm } },
            .load_extern_func => |extern_func| .{ .base = .{ .extern_func = extern_func }, .mod = .{ .rm = mod_rm } },
            .air_ref => |ref| (try function.resolveInst(ref)).mem(function, mod_rm),
        };
    }

    pub fn format(mcv: MCValue, w: *Writer) Writer.Error!void {
        switch (mcv) {
            .none, .unreach, .dead, .undef => try w.print("({s})", .{@tagName(mcv)}),
            .immediate => |pl| try w.print("0x{x}", .{pl}),
            .memory => |pl| try w.print("[ds:0x{x}]", .{pl}),
            inline .eflags, .register => |pl| try w.print("{s}", .{@tagName(pl)}),
            .register_pair => |pl| try w.print("{s}:{s}", .{ @tagName(pl[1]), @tagName(pl[0]) }),
            .register_triple => |pl| try w.print("{s}:{s}:{s}", .{
                @tagName(pl[2]), @tagName(pl[1]), @tagName(pl[0]),
            }),
            .register_quadruple => |pl| try w.print("{s}:{s}:{s}:{s}", .{
                @tagName(pl[3]), @tagName(pl[2]), @tagName(pl[1]), @tagName(pl[0]),
            }),
            .register_offset => |pl| try w.print("{s} + 0x{x}", .{ @tagName(pl.reg), pl.off }),
            .register_overflow => |pl| try w.print("{s}:{s}", .{
                @tagName(pl.eflags),
                @tagName(pl.reg),
            }),
            .register_mask => |pl| try w.print("mask({s},{f}):{c}{s}", .{
                @tagName(pl.info.kind),
                pl.info.scalar,
                @as(u8, if (pl.info.inverted) '!' else ' '),
                @tagName(pl.reg),
            }),
            .indirect => |pl| try w.print("[{s} + 0x{x}]", .{ @tagName(pl.reg), pl.off }),
            .indirect_load_frame => |pl| try w.print("[[{f} + 0x{x}]]", .{ pl.index, pl.off }),
            .load_frame => |pl| try w.print("[{f} + 0x{x}]", .{ pl.index, pl.off }),
            .lea_frame => |pl| try w.print("{f} + 0x{x}", .{ pl.index, pl.off }),
            .load_nav => |pl| try w.print("[nav:{d}]", .{@intFromEnum(pl)}),
            .lea_nav => |pl| try w.print("nav:{d}", .{@intFromEnum(pl)}),
            .load_uav => |pl| try w.print("[uav:{d}]", .{@intFromEnum(pl.val)}),
            .lea_uav => |pl| try w.print("uav:{d}", .{@intFromEnum(pl.val)}),
            .load_lazy_sym => |pl| try w.print("[lazy:{s}:{d}]", .{ @tagName(pl.kind), @intFromEnum(pl.ty) }),
            .lea_lazy_sym => |pl| try w.print("lazy:{s}:{d}", .{ @tagName(pl.kind), @intFromEnum(pl.ty) }),
            .load_extern_func => |pl| try w.print("[extern:{d}]", .{@intFromEnum(pl)}),
            .lea_extern_func => |pl| try w.print("extern:{d}", .{@intFromEnum(pl)}),
            .elementwise_args => |pl| try w.print("elementwise:{d}:[{f} + 0x{x}]", .{
                pl.regs, pl.frame_index, pl.frame_off,
            }),
            .reserved_frame => |pl| try w.print("(dead:{f})", .{pl}),
            .air_ref => |pl| try w.print("(air:0x{x})", .{@intFromEnum(pl)}),
        }
    }
};

const InstTrackingMap = std.AutoArrayHashMapUnmanaged(Air.Inst.Index, InstTracking);
const ConstTrackingMap = std.AutoArrayHashMapUnmanaged(InternPool.Index, InstTracking);
const InstTracking = struct {
    long: MCValue,
    short: MCValue,

    fn init(result: MCValue) InstTracking {
        return .{ .long = switch (result) {
            .none,
            .unreach,
            .undef,
            .immediate,
            .memory,
            .indirect_load_frame,
            .load_frame,
            .lea_frame,
            .load_nav,
            .lea_nav,
            .load_uav,
            .lea_uav,
            .load_lazy_sym,
            .lea_lazy_sym,
            .load_extern_func,
            .lea_extern_func,
            => result,
            .dead,
            .elementwise_args,
            .reserved_frame,
            .air_ref,
            => unreachable,
            .eflags,
            .register,
            .register_pair,
            .register_triple,
            .register_quadruple,
            .register_offset,
            .register_overflow,
            .register_mask,
            .indirect,
            => .none,
        }, .short = result };
    }

    fn getReg(self: InstTracking) ?Register {
        return self.short.getReg();
    }

    fn getRegs(self: *const InstTracking) []const Register {
        return self.short.getRegs();
    }

    fn getCondition(self: InstTracking) ?Condition {
        return self.short.getCondition();
    }

    fn spill(self: *InstTracking, cg: *CodeGen, inst: Air.Inst.Index) !void {
        if (std.meta.eql(self.long, self.short)) return; // Already spilled
        // Allocate or reuse frame index
        switch (self.long) {
            .none => self.long = try cg.allocRegOrMem(inst, false),
            .load_frame => {},
            .lea_frame => return,
            .reserved_frame => |index| self.long = .{ .load_frame = .{ .index = index } },
            else => unreachable,
        }
        tracking_log.debug("spill {f} from {f} to {f}", .{ inst, self.short, self.long });
        try cg.genCopy(cg.typeOfIndex(inst), self.long, self.short, .{});
        for (self.short.getRegs()) |reg| if (reg.isClass(.x87)) try cg.asmRegister(.{ .f_, .free }, reg);
    }

    fn reuseFrame(self: *InstTracking) void {
        self.* = .init(switch (self.long) {
            .none => switch (self.short) {
                .dead => .none,
                else => |short| short,
            },
            .reserved_frame => |index| .{ .load_frame = .{ .index = index } },
            else => |long| long,
        });
    }

    fn trackSpill(self: *InstTracking, function: *CodeGen, inst: Air.Inst.Index) !void {
        switch (self.short) {
            .register => |reg| function.register_manager.freeReg(reg),
            inline .register_pair,
            .register_triple,
            .register_quadruple,
            => |regs| for (regs) |reg| function.register_manager.freeReg(reg),
            .register_offset, .indirect => |reg_off| function.register_manager.freeReg(reg_off.reg),
            .register_overflow => |reg_ov| {
                function.register_manager.freeReg(reg_ov.reg);
                function.eflags_inst = null;
            },
            .register_mask => |reg_mask| function.register_manager.freeReg(reg_mask.reg),
            .eflags => function.eflags_inst = null,
            else => {}, // TODO process stack allocation death
        }
        self.reuseFrame();
        tracking_log.debug("{f} => {f} (spilled)", .{ inst, self.* });
    }

    fn verifyMaterialize(self: InstTracking, target: InstTracking) void {
        switch (self.long) {
            .none,
            .load_frame,
            .reserved_frame,
            => switch (target.long) {
                .none,
                .load_frame,
                .reserved_frame,
                => {},
                else => unreachable,
            },
            .unreach,
            .undef,
            .immediate,
            .memory,
            .indirect_load_frame,
            .lea_frame,
            .load_nav,
            .lea_nav,
            .load_uav,
            .lea_uav,
            .load_lazy_sym,
            .lea_lazy_sym,
            .load_extern_func,
            .lea_extern_func,
            => assert(std.meta.eql(self.long, target.long)),
            .dead,
            .eflags,
            .register,
            .register_pair,
            .register_triple,
            .register_quadruple,
            .register_offset,
            .register_overflow,
            .register_mask,
            .indirect,
            .elementwise_args,
            .air_ref,
            => unreachable,
        }
    }

    fn materialize(
        self: *InstTracking,
        function: *CodeGen,
        inst: Air.Inst.Index,
        target: InstTracking,
    ) !void {
        self.verifyMaterialize(target);
        try self.materializeUnsafe(function, inst, target);
    }

    fn materializeUnsafe(
        self: InstTracking,
        function: *CodeGen,
        inst: Air.Inst.Index,
        target: InstTracking,
    ) !void {
        const ty = function.typeOfIndex(inst);
        if ((self.long == .none or self.long == .reserved_frame) and target.long == .load_frame)
            try function.genCopy(ty, target.long, self.short, .{});
        try function.genCopy(ty, target.short, self.short, .{});
    }

    fn trackMaterialize(self: *InstTracking, inst: Air.Inst.Index, target: InstTracking) void {
        self.verifyMaterialize(target);
        // Don't clobber reserved frame indices
        self.long = if (target.long == .none) switch (self.long) {
            .load_frame => |addr| .{ .reserved_frame = addr.index },
            .reserved_frame => self.long,
            else => target.long,
        } else target.long;
        self.short = target.short;
        tracking_log.debug("{f} => {f} (materialize)", .{ inst, self.* });
    }

    fn resurrect(self: *InstTracking, function: *CodeGen, inst: Air.Inst.Index, scope_generation: u32) !void {
        switch (self.short) {
            .dead => |die_generation| if (die_generation >= scope_generation) {
                self.reuseFrame();
                try function.getValue(self.short, inst);
                tracking_log.debug("{f} => {f} (resurrect)", .{ inst, self.* });
            },
            else => {},
        }
    }

    fn die(self: *InstTracking, function: *CodeGen, inst: Air.Inst.Index, comptime opts: FreeOptions) !void {
        if (self.short == .dead) return;
        try function.freeValue(self.short, opts);
        if (self.long == .none) self.long = self.short;
        self.short = .{ .dead = function.scope_generation };
        tracking_log.debug("{f} => {f} (death)", .{ inst, self.* });
    }

    fn reuse(
        self: *InstTracking,
        function: *CodeGen,
        new_inst: ?Air.Inst.Index,
        old_inst: Air.Inst.Index,
    ) void {
        self.short = .{ .dead = function.scope_generation };
        tracking_log.debug("{?f} => {f} (reuse {f})", .{ new_inst, self.*, old_inst });
    }

    fn liveOut(self: *InstTracking, function: *CodeGen, inst: Air.Inst.Index) void {
        for (self.getRegs()) |reg| {
            if (function.register_manager.isRegFree(reg)) {
                tracking_log.debug("{f} => {f} (live-out)", .{ inst, self.* });
                continue;
            }

            const index = RegisterManager.indexOfRegIntoTracked(reg).?;
            const tracked_inst = function.register_manager.registers[index];
            const tracking = function.getResolvedInstValue(tracked_inst);

            // Disable death.
            var found_reg = false;
            var remaining_reg: Register = .none;
            for (tracking.getRegs()) |tracked_reg| if (tracked_reg.id() == reg.id()) {
                assert(!found_reg);
                found_reg = true;
            } else {
                assert(remaining_reg == .none);
                remaining_reg = tracked_reg;
            };
            assert(found_reg);
            if (tracking.long == .none) tracking.long = tracking.short;
            tracking.short = switch (remaining_reg) {
                .none => .{ .dead = function.scope_generation },
                else => .{ .register = remaining_reg },
            };

            // Perform side-effects of freeValue manually.
            function.register_manager.freeReg(reg);

            tracking_log.debug("{f} => {f} (live-out {f})", .{ inst, self.*, tracked_inst });
        }
    }

    pub fn format(tracking: InstTracking, bw: *Writer) Writer.Error!void {
        if (!std.meta.eql(tracking.long, tracking.short)) try bw.print("|{f}| ", .{tracking.long});
        try bw.print("{f}", .{tracking.short});
    }
};

const FrameAlloc = struct {
    abi_size: u31,
    spill_pad: u3,
    abi_align: InternPool.Alignment,
    ref_count: u16,

    fn init(alloc_abi: struct { size: u64, pad: u3 = 0, alignment: InternPool.Alignment }) FrameAlloc {
        return .{
            .abi_size = @intCast(alloc_abi.size),
            .spill_pad = alloc_abi.pad,
            .abi_align = alloc_abi.alignment,
            .ref_count = 0,
        };
    }
    fn initType(ty: Type, zcu: *Zcu) FrameAlloc {
        return init(.{
            .size = ty.abiSize(zcu),
            .alignment = ty.abiAlignment(zcu),
        });
    }
    fn initSpill(ty: Type, zcu: *Zcu) FrameAlloc {
        const abi_size = ty.abiSize(zcu);
        const spill_size = if (abi_size < 8)
            std.math.ceilPowerOfTwoAssert(u64, abi_size)
        else
            std.mem.alignForward(u64, abi_size, 8);
        return init(.{
            .size = spill_size,
            .pad = @intCast(spill_size - abi_size),
            .alignment = ty.abiAlignment(zcu).maxStrict(
                .fromNonzeroByteUnits(@min(spill_size, 8)),
            ),
        });
    }
};

const BlockData = struct {
    relocs: std.ArrayList(Mir.Inst.Index) = .empty,
    state: State,

    fn deinit(self: *BlockData, gpa: Allocator) void {
        self.relocs.deinit(gpa);
        self.* = undefined;
    }
};

const CodeGen = @This();

pub fn generate(
    bin_file: *link.File,
    pt: Zcu.PerThread,
    src_loc: Zcu.LazySrcLoc,
    func_index: InternPool.Index,
    air: *const Air,
    liveness: *const ?Air.Liveness,
) codegen.CodeGenError!Mir {
    _ = bin_file;
    const zcu = pt.zcu;
    const gpa = zcu.gpa;
    const ip = &zcu.intern_pool;
    const func = zcu.funcInfo(func_index);
    const func_zir = func.zir_body_inst.resolveFull(ip).?;
    const file = zcu.fileByIndex(func_zir.file);
    const fn_type: Type = .fromInterned(func.ty);
    const mod = file.mod.?;

    var function: CodeGen = .{
        .gpa = gpa,
        .pt = pt,
        .air = air.*,
        .liveness = liveness.*.?,
        .target = &mod.resolved_target.result,
        .mod = mod,
        .owner = .{ .nav_index = func.owner_nav },
        .inline_func = func_index,
        .args = undefined, // populated after `resolveCallingConventionValues`
        .va_info = undefined, // populated after `resolveCallingConventionValues`
        .ret_mcv = undefined, // populated after `resolveCallingConventionValues`
        .err_ret_trace_reg = undefined, // populated after `resolveCallingConventionValues`
        .fn_type = fn_type,
        .src_loc = src_loc,
    };
    defer {
        function.frame_allocs.deinit(gpa);
        function.free_frame_indices.deinit(gpa);
        function.frame_locs.deinit(gpa);
        function.loops.deinit(gpa);
        function.loop_switches.deinit(gpa);
        var block_it = function.blocks.valueIterator();
        while (block_it.next()) |block| block.deinit(gpa);
        function.blocks.deinit(gpa);
        function.inst_tracking.deinit(gpa);
        function.epilogue_relocs.deinit(gpa);
        function.mir_instructions.deinit(gpa);
        function.mir_string_bytes.deinit(gpa);
        function.mir_strings.deinit(gpa);
        function.mir_locals.deinit(gpa);
        function.mir_extra.deinit(gpa);
        function.mir_table.deinit(gpa);
    }
    try function.inst_tracking.ensureTotalCapacity(gpa, Temp.Index.max);
    for (0..Temp.Index.max) |temp_index| {
        const temp: Temp.Index = @enumFromInt(temp_index);
        function.inst_tracking.putAssumeCapacityNoClobber(temp.toIndex(), .init(.none));
    }

    wip_mir_log.debug("{f}:", .{fmtNav(func.owner_nav, ip)});

    try function.frame_allocs.resize(gpa, FrameIndex.named_count);
    function.frame_allocs.set(
        @intFromEnum(FrameIndex.stack_frame),
        .init(.{ .size = 0, .alignment = .@"1" }),
    );
    function.frame_allocs.set(
        @intFromEnum(FrameIndex.call_frame),
        .init(.{ .size = 0, .alignment = .@"1" }),
    );

    const fn_info = zcu.typeToFunc(fn_type).?;
    var call_info = function.resolveCallingConventionValues(fn_info, &.{}, .args_frame) catch |err| switch (err) {
        error.CodegenFail => return error.CodegenFail,
        else => |e| return e,
    };
    defer call_info.deinit(&function);

    function.args = call_info.args;
    function.ret_mcv = call_info.return_value;
    function.err_ret_trace_reg = call_info.err_ret_trace_reg;
    function.frame_allocs.set(@intFromEnum(FrameIndex.ret_addr), .init(.{
        .size = Type.usize.abiSize(zcu),
        .alignment = Type.usize.abiAlignment(zcu).min(call_info.stack_align),
    }));
    function.frame_allocs.set(@intFromEnum(FrameIndex.base_ptr), .init(.{
        .size = Type.usize.abiSize(zcu),
        .alignment = call_info.stack_align.min(
            .fromNonzeroByteUnits(function.target.stackAlignment()),
        ),
    }));
    function.frame_allocs.set(
        @intFromEnum(FrameIndex.args_frame),
        .init(.{
            .size = call_info.stack_byte_count,
            .alignment = call_info.stack_align,
        }),
    );
    function.va_info = switch (fn_info.cc) {
        else => undefined,
        .x86_64_sysv => .{ .sysv = .{
            .gp_count = call_info.gp_count,
            .fp_count = call_info.fp_count,
            .overflow_arg_area = .{ .index = .args_frame, .off = call_info.stack_byte_count },
            .reg_save_area = undefined,
        } },
        .x86_64_win => .{ .win64 = .{} },
    };
    if (call_info.err_ret_trace_reg != .none) {
        function.register_manager.getRegAssumeFree(call_info.err_ret_trace_reg, err_ret_trace_index);
        try function.inst_tracking.putNoClobber(
            gpa,
            err_ret_trace_index,
            .init(.{ .register = call_info.err_ret_trace_reg }),
        );
    }

    function.gen(&file.zir.?, func_zir.inst, func.comptime_args, call_info.air_arg_count) catch |err| switch (err) {
        error.CodegenFail => return error.CodegenFail,
        error.OutOfRegisters => return function.fail("ran out of registers (Zig compiler bug)", .{}),
        else => |e| return e,
    };

    // Drop them off at the rbrace.
    if (!mod.strip) _ = try function.addInst(.{
        .tag = .pseudo,
        .ops = .pseudo_dbg_line_line_column,
        .data = .{ .line_column = .{
            .line = func.rbrace_line,
            .column = func.rbrace_column,
        } },
    });

    var mir: Mir = .{
        .instructions = .empty,
        .extra = &.{},
        .string_bytes = &.{},
        .locals = &.{},
        .table = &.{},
        .frame_locs = .empty,
    };
    errdefer mir.deinit(gpa);
    mir.instructions = function.mir_instructions.toOwnedSlice();
    mir.extra = try function.mir_extra.toOwnedSlice(gpa);
    mir.string_bytes = try function.mir_string_bytes.toOwnedSlice(gpa);
    mir.locals = try function.mir_locals.toOwnedSlice(gpa);
    mir.table = try function.mir_table.toOwnedSlice(gpa);
    mir.frame_locs = function.frame_locs.toOwnedSlice();
    return mir;
}

pub fn getTmpMir(cg: *CodeGen) Mir {
    return .{
        .instructions = cg.mir_instructions.slice(),
        .extra = cg.mir_extra.items,
        .string_bytes = cg.mir_string_bytes.items,
        .locals = cg.mir_locals.items,
        .table = cg.mir_table.items,
        .frame_locs = cg.frame_locs.slice(),
    };
}

pub fn generateLazy(
    bin_file: *link.File,
    pt: Zcu.PerThread,
    src_loc: Zcu.LazySrcLoc,
    lazy_sym: link.File.LazySymbol,
    atom_index: u32,
    w: *std.Io.Writer,
    debug_output: link.File.DebugInfoOutput,
) codegen.CodeGenError!void {
    const gpa = pt.zcu.gpa;
    // This function is for generating global code, so we use the root module.
    const mod = pt.zcu.comp.root_mod;
    var function: CodeGen = .{
        .gpa = gpa,
        .pt = pt,
        .air = undefined,
        .liveness = undefined,
        .target = &mod.resolved_target.result,
        .mod = mod,
        .owner = .{ .lazy_sym = lazy_sym },
        .inline_func = undefined,
        .args = undefined,
        .va_info = undefined,
        .ret_mcv = undefined,
        .err_ret_trace_reg = undefined,
        .fn_type = undefined,
        .src_loc = src_loc,
    };
    defer {
        function.inst_tracking.deinit(gpa);
        function.mir_instructions.deinit(gpa);
        function.mir_string_bytes.deinit(gpa);
        function.mir_strings.deinit(gpa);
        function.mir_locals.deinit(gpa);
        function.mir_extra.deinit(gpa);
        function.mir_table.deinit(gpa);
    }
    try function.inst_tracking.ensureTotalCapacity(gpa, Temp.Index.max);
    for (0..Temp.Index.max) |temp_index| {
        const temp: Temp.Index = @enumFromInt(temp_index);
        function.inst_tracking.putAssumeCapacityNoClobber(temp.toIndex(), .init(.none));
    }

    function.genLazy(lazy_sym) catch |err| switch (err) {
        error.CodegenFail => return error.CodegenFail,
        error.OutOfRegisters => return function.fail("ran out of registers (Zig compiler bug)", .{}),
        else => |e| return e,
    };

    try function.getTmpMir().emitLazy(bin_file, pt, src_loc, lazy_sym, atom_index, w, debug_output);
}

const FormatNavData = struct {
    ip: *const InternPool,
    nav_index: InternPool.Nav.Index,
};
fn formatNav(data: FormatNavData, w: *Writer) Writer.Error!void {
    try w.print("{f}", .{data.ip.getNav(data.nav_index).fqn.fmt(data.ip)});
}
fn fmtNav(nav_index: InternPool.Nav.Index, ip: *const InternPool) std.fmt.Alt(FormatNavData, formatNav) {
    return .{ .data = .{
        .ip = ip,
        .nav_index = nav_index,
    } };
}

const FormatAirData = struct {
    self: *CodeGen,
    inst: Air.Inst.Index,
};
fn formatAir(data: FormatAirData, w: *Writer) Writer.Error!void {
    data.self.air.writeInst(w, data.inst, data.self.pt, data.self.liveness);
}
fn fmtAir(self: *CodeGen, inst: Air.Inst.Index) std.fmt.Alt(FormatAirData, formatAir) {
    return .{ .data = .{ .self = self, .inst = inst } };
}

const FormatWipMirData = struct {
    self: *CodeGen,
    inst: Mir.Inst.Index,
};
fn formatWipMir(data: FormatWipMirData, w: *Writer) Writer.Error!void {
    var lower: Lower = .{
        .target = data.self.target,
        .allocator = data.self.gpa,
        .mir = data.self.getTmpMir(),
        .cc = .auto,
        .src_loc = data.self.src_loc,
    };
    var first = true;
    for ((lower.lowerMir(data.inst) catch |err| switch (err) {
        error.LowerFail => {
            defer {
                lower.err_msg.?.deinit(data.self.gpa);
                lower.err_msg = null;
            }
            try w.writeAll(lower.err_msg.?.msg);
            return;
        },
        else => |e| {
            try w.writeAll(@errorName(e));
            return;
        },
    }).insts) |lowered_inst| {
        if (!first) try w.writeAll("\ndebug(wip_mir): ");
        try w.print("  | {f}", .{lowered_inst});
        first = false;
    }
    if (first) {
        const ip = &data.self.pt.zcu.intern_pool;
        const mir_inst = lower.mir.instructions.get(data.inst);
        try w.print("  | .{s}", .{@tagName(mir_inst.ops)});
        switch (mir_inst.ops) {
            else => unreachable,
            .pseudo_dbg_prologue_end_none,
            .pseudo_dbg_epilogue_begin_none,
            .pseudo_dbg_enter_block_none,
            .pseudo_dbg_leave_block_none,
            .pseudo_dbg_arg_none,
            .pseudo_dbg_var_args_none,
            .pseudo_dbg_var_none,
            .pseudo_dead_none,
            => {},
            .pseudo_dbg_line_stmt_line_column, .pseudo_dbg_line_line_column => try w.print(
                " {[line]d}, {[column]d}",
                mir_inst.data.line_column,
            ),
            .pseudo_dbg_enter_inline_func, .pseudo_dbg_leave_inline_func => try w.print(" {f}", .{
                ip.getNav(ip.indexToKey(mir_inst.data.ip_index).func.owner_nav).name.fmt(ip),
            }),
            .pseudo_dbg_arg_i_s, .pseudo_dbg_var_i_s => try w.print(" {d}", .{
                @as(i32, @bitCast(mir_inst.data.i.i)),
            }),
            .pseudo_dbg_arg_i_u, .pseudo_dbg_var_i_u => try w.print(" {d}", .{
                mir_inst.data.i.i,
            }),
            .pseudo_dbg_arg_i_64, .pseudo_dbg_var_i_64 => try w.print(" {d}", .{
                mir_inst.data.i64,
            }),
            .pseudo_dbg_arg_ro, .pseudo_dbg_var_ro => {
                const mem_op: encoder.Instruction.Operand = .{ .mem = .initSib(.qword, .{
                    .base = .{ .reg = mir_inst.data.ro.reg },
                    .disp = mir_inst.data.ro.off,
                }) };
                try w.print(" {f}", .{mem_op.fmt(.m)});
            },
            .pseudo_dbg_arg_fa, .pseudo_dbg_var_fa => {
                const mem_op: encoder.Instruction.Operand = .{ .mem = .initSib(.qword, .{
                    .base = .{ .frame = mir_inst.data.fa.index },
                    .disp = mir_inst.data.fa.off,
                }) };
                try w.print(" {f}", .{mem_op.fmt(.m)});
            },
            .pseudo_dbg_arg_m, .pseudo_dbg_var_m => {
                const mem_op: encoder.Instruction.Operand = .{
                    .mem = lower.mir.extraData(Mir.Memory, mir_inst.data.x.payload).data.decode(),
                };
                try w.print(" {f}", .{mem_op.fmt(.m)});
            },
            .pseudo_dbg_arg_val, .pseudo_dbg_var_val => try w.print(" {f}", .{
                Value.fromInterned(mir_inst.data.ip_index).fmtValue(data.self.pt),
            }),
        }
    }
}
fn fmtWipMir(self: *CodeGen, inst: Mir.Inst.Index) std.fmt.Alt(FormatWipMirData, formatWipMir) {
    return .{ .data = .{ .self = self, .inst = inst } };
}

const FormatTrackingData = struct {
    self: *CodeGen,
};
fn formatTracking(data: FormatTrackingData, w: *Writer) Writer.Error!void {
    var it = data.self.inst_tracking.iterator();
    while (it.next()) |entry| try w.print("\n{f} = {f}", .{ entry.key_ptr.*, entry.value_ptr.* });
}
fn fmtTracking(self: *CodeGen) std.fmt.Alt(FormatTrackingData, formatTracking) {
    return .{ .data = .{ .self = self } };
}

fn addInst(self: *CodeGen, inst: Mir.Inst) error{OutOfMemory}!Mir.Inst.Index {
    const gpa = self.gpa;
    try self.mir_instructions.ensureUnusedCapacity(gpa, 1);
    const result_index: Mir.Inst.Index = @intCast(self.mir_instructions.len);
    self.mir_instructions.appendAssumeCapacity(inst);
    if (inst.ops != .pseudo_dead_none) wip_mir_log.debug("{f}", .{self.fmtWipMir(result_index)});
    return result_index;
}

fn addExtra(self: *CodeGen, extra: anytype) Allocator.Error!u32 {
    const fields = std.meta.fields(@TypeOf(extra));
    try self.mir_extra.ensureUnusedCapacity(self.gpa, fields.len);
    return self.addExtraAssumeCapacity(extra);
}

fn addExtraAssumeCapacity(self: *CodeGen, extra: anytype) u32 {
    const fields = std.meta.fields(@TypeOf(extra));
    const result: u32 = @intCast(self.mir_extra.items.len);
    inline for (fields) |field| {
        self.mir_extra.appendAssumeCapacity(switch (field.type) {
            u32 => @field(extra, field.name),
            i32, Mir.Memory.Info => @bitCast(@field(extra, field.name)),
            FrameIndex => @intFromEnum(@field(extra, field.name)),
            else => @compileError("bad field type: " ++ field.name ++ ": " ++ @typeName(field.type)),
        });
    }
    return result;
}

fn addString(cg: *CodeGen, string: []const u8) Allocator.Error!Mir.NullTerminatedString {
    try cg.mir_string_bytes.ensureUnusedCapacity(cg.gpa, string.len + 1);
    try cg.mir_strings.ensureUnusedCapacityContext(cg.gpa, 1, .{ .bytes = &cg.mir_string_bytes });

    const mir_string_gop = cg.mir_strings.getOrPutAssumeCapacityAdapted(
        string,
        std.hash_map.StringIndexAdapter{ .bytes = &cg.mir_string_bytes },
    );
    if (!mir_string_gop.found_existing) {
        mir_string_gop.key_ptr.* = @intCast(cg.mir_string_bytes.items.len);
        cg.mir_string_bytes.appendSliceAssumeCapacity(string);
        cg.mir_string_bytes.appendAssumeCapacity(0);
    }
    return @enumFromInt(mir_string_gop.key_ptr.*);
}

fn asmOps(self: *CodeGen, tag: Mir.Inst.FixedTag, ops: [4]Operand) !void {
    return switch (ops[0]) {
        .none => self.asmOpOnly(tag),
        .reg => |reg0| switch (ops[1]) {
            .none => self.asmRegister(tag, reg0),
            .reg => |reg1| switch (ops[2]) {
                .none => self.asmRegisterRegister(tag, reg0, reg1),
                .reg => |reg2| switch (ops[3]) {
                    .none => self.asmRegisterRegisterRegister(tag, reg0, reg1, reg2),
                    .reg => |reg3| self.asmRegisterRegisterRegisterRegister(tag, reg0, reg1, reg2, reg3),
                    .imm => |imm3| self.asmRegisterRegisterRegisterImmediate(tag, reg0, reg1, reg2, imm3),
                    else => error.InvalidInstruction,
                },
                .mem => |mem2| switch (ops[3]) {
                    .none => self.asmRegisterRegisterMemory(tag, reg0, reg1, mem2),
                    .reg => |reg3| self.asmRegisterRegisterMemoryRegister(tag, reg0, reg1, mem2, reg3),
                    .imm => |imm3| self.asmRegisterRegisterMemoryImmediate(tag, reg0, reg1, mem2, imm3),
                    else => error.InvalidInstruction,
                },
                .imm => |imm2| switch (ops[3]) {
                    .none => self.asmRegisterRegisterImmediate(tag, reg0, reg1, imm2),
                    else => error.InvalidInstruction,
                },
                else => error.InvalidInstruction,
            },
            .mem => |mem1| switch (ops[2]) {
                .none => self.asmRegisterMemory(tag, reg0, mem1),
                .reg => |reg2| switch (ops[3]) {
                    .none => self.asmRegisterMemoryRegister(tag, reg0, mem1, reg2),
                    else => error.InvalidInstruction,
                },
                .imm => |imm2| switch (ops[3]) {
                    .none => self.asmRegisterMemoryImmediate(tag, reg0, mem1, imm2),
                    else => error.InvalidInstruction,
                },
                else => error.InvalidInstruction,
            },
            .imm => |imm1| switch (ops[2]) {
                .none => self.asmRegisterImmediate(tag, reg0, imm1),
                else => error.InvalidInstruction,
            },
            else => error.InvalidInstruction,
        },
        .mem => |mem0| switch (ops[1]) {
            .none => self.asmMemory(tag, mem0),
            .reg => |reg1| switch (ops[2]) {
                .none => self.asmMemoryRegister(tag, mem0, reg1),
                .reg => |reg2| switch (ops[3]) {
                    .none => self.asmMemoryRegisterRegister(tag, mem0, reg1, reg2),
                    else => error.InvalidInstruction,
                },
                .imm => |imm2| switch (ops[3]) {
                    .none => self.asmMemoryRegisterImmediate(tag, mem0, reg1, imm2),
                    else => error.InvalidInstruction,
                },
                else => error.InvalidInstruction,
            },
            .imm => |imm1| switch (ops[2]) {
                .none => self.asmMemoryImmediate(tag, mem0, imm1),
                else => error.InvalidInstruction,
            },
            else => error.InvalidInstruction,
        },
        .imm => |imm0| switch (ops[1]) {
            .none => self.asmImmediate(tag, imm0),
            .reg => |reg1| switch (ops[2]) {
                .none => self.asmImmediateRegister(tag, imm0, reg1),
                else => error.InvalidInstruction,
            },
            .imm => |imm1| switch (ops[2]) {
                .none => self.asmImmediateImmediate(tag, imm0, imm1),
                else => error.InvalidInstruction,
            },
            else => error.InvalidInstruction,
        },
        .inst => |inst0| switch (ops[1]) {
            .none => self.asmReloc(tag, inst0),
            else => error.InvalidInstruction,
        },
    };
}

/// A `cc` of `.z_and_np` clobbers `reg2`!
fn asmCmovccRegisterRegister(self: *CodeGen, cc: Condition, reg1: Register, reg2: Register) !void {
    if (self.hasFeature(.cmov)) _ = try self.addInst(.{
        .tag = switch (cc) {
            else => .cmov,
            .z_and_np, .nz_or_p => .pseudo,
        },
        .ops = switch (cc) {
            else => .rr,
            .z_and_np => .pseudo_cmov_z_and_np_rr,
            .nz_or_p => .pseudo_cmov_nz_or_p_rr,
        },
        .data = .{ .rr = .{
            .fixes = switch (cc) {
                else => .fromCond(cc),
                .z_and_np, .nz_or_p => ._,
            },
            .r1 = reg1,
            .r2 = reg2,
        } },
    }) else {
        const reloc = try self.asmJccReloc(cc.negate(), undefined);
        try self.asmRegisterRegister(.{ ._, .mov }, reg1, reg2);
        self.performReloc(reloc);
    }
}

/// A `cc` of `.z_and_np` is not supported by this encoding!
fn asmCmovccRegisterMemory(self: *CodeGen, cc: Condition, reg: Register, m: Memory) !void {
    if (self.hasFeature(.cmov)) _ = try self.addInst(.{
        .tag = switch (cc) {
            else => .cmov,
            .z_and_np => unreachable,
            .nz_or_p => .pseudo,
        },
        .ops = switch (cc) {
            else => .rm,
            .z_and_np => unreachable,
            .nz_or_p => .pseudo_cmov_nz_or_p_rm,
        },
        .data = .{ .rx = .{
            .fixes = switch (cc) {
                else => .fromCond(cc),
                .z_and_np => unreachable,
                .nz_or_p => ._,
            },
            .r1 = reg,
            .payload = try self.addExtra(Mir.Memory.encode(m)),
        } },
    }) else {
        const reloc = try self.asmJccReloc(cc.negate(), undefined);
        try self.asmRegisterMemory(.{ ._, .mov }, reg, m);
        self.performReloc(reloc);
    }
}

fn asmSetccRegister(self: *CodeGen, cc: Condition, reg: Register) !void {
    _ = try self.addInst(.{
        .tag = switch (cc) {
            else => .set,
            .z_and_np, .nz_or_p => .pseudo,
        },
        .ops = switch (cc) {
            else => .r,
            .z_and_np => .pseudo_set_z_and_np_r,
            .nz_or_p => .pseudo_set_nz_or_p_r,
        },
        .data = switch (cc) {
            else => .{ .r = .{
                .fixes = .fromCond(cc),
                .r1 = reg,
            } },
            .z_and_np, .nz_or_p => .{ .rr = .{
                .r1 = reg,
                .r2 = (try self.register_manager.allocReg(null, abi.RegisterClass.gp)).to8(),
            } },
        },
    });
}

fn asmSetccMemory(self: *CodeGen, cc: Condition, m: Memory) !void {
    const payload = try self.addExtra(Mir.Memory.encode(m));
    _ = try self.addInst(.{
        .tag = switch (cc) {
            else => .set,
            .z_and_np, .nz_or_p => .pseudo,
        },
        .ops = switch (cc) {
            else => .m,
            .z_and_np => .pseudo_set_z_and_np_m,
            .nz_or_p => .pseudo_set_nz_or_p_m,
        },
        .data = switch (cc) {
            else => .{ .x = .{
                .fixes = .fromCond(cc),
                .payload = payload,
            } },
            .z_and_np, .nz_or_p => .{ .rx = .{
                .r1 = (try self.register_manager.allocReg(null, abi.RegisterClass.gp)).to8(),
                .payload = payload,
            } },
        },
    });
}

fn asmJmpReloc(self: *CodeGen, target: Mir.Inst.Index) !Mir.Inst.Index {
    return self.addInst(.{
        .tag = .j,
        .ops = .inst,
        .data = .{ .inst = .{
            .fixes = ._mp,
            .inst = target,
        } },
    });
}

fn asmJccReloc(self: *CodeGen, cc: Condition, target: Mir.Inst.Index) !Mir.Inst.Index {
    return self.addInst(.{
        .tag = switch (cc) {
            else => .j,
            .z_and_np, .nz_or_p => .pseudo,
        },
        .ops = switch (cc) {
            else => .inst,
            .z_and_np => .pseudo_j_z_and_np_inst,
            .nz_or_p => .pseudo_j_nz_or_p_inst,
        },
        .data = .{ .inst = .{
            .fixes = switch (cc) {
                else => .fromCond(cc),
                .z_and_np, .nz_or_p => ._,
            },
            .inst = target,
        } },
    });
}

fn asmReloc(self: *CodeGen, tag: Mir.Inst.FixedTag, target: Mir.Inst.Index) !void {
    _ = try self.addInst(.{
        .tag = tag[1],
        .ops = .inst,
        .data = .{ .inst = .{
            .fixes = tag[0],
            .inst = target,
        } },
    });
}

fn asmPlaceholder(self: *CodeGen) !Mir.Inst.Index {
    return self.addInst(.{
        .tag = .pseudo,
        .ops = .pseudo_dead_none,
        .data = undefined,
    });
}

fn asmOpOnly(self: *CodeGen, tag: Mir.Inst.FixedTag) !void {
    _ = try self.addInst(.{
        .tag = tag[1],
        .ops = .none,
        .data = .{ .none = .{
            .fixes = tag[0],
        } },
    });
}

fn asmPseudo(self: *CodeGen, ops: Mir.Inst.Ops) !void {
    assert(std.mem.startsWith(u8, @tagName(ops), "pseudo_") and
        std.mem.endsWith(u8, @tagName(ops), "_none"));
    _ = try self.addInst(.{
        .tag = .pseudo,
        .ops = ops,
        .data = undefined,
    });
}

fn asmPseudoRegister(self: *CodeGen, ops: Mir.Inst.Ops, reg: Register) !void {
    assert(std.mem.startsWith(u8, @tagName(ops), "pseudo_") and
        std.mem.endsWith(u8, @tagName(ops), "_r"));
    _ = try self.addInst(.{
        .tag = .pseudo,
        .ops = ops,
        .data = .{ .r = .{ .r1 = reg } },
    });
}

fn asmPseudoImmediate(self: *CodeGen, ops: Mir.Inst.Ops, imm: Immediate) !void {
    assert(std.mem.startsWith(u8, @tagName(ops), "pseudo_") and
        std.mem.endsWith(u8, @tagName(ops), "_i_s"));
    _ = try self.addInst(.{
        .tag = .pseudo,
        .ops = ops,
        .data = .{ .i = .{ .i = @bitCast(imm.signed) } },
    });
}

fn asmPseudoRegisterRegister(self: *CodeGen, ops: Mir.Inst.Ops, reg1: Register, reg2: Register) !void {
    assert(std.mem.startsWith(u8, @tagName(ops), "pseudo_") and
        std.mem.endsWith(u8, @tagName(ops), "_rr"));
    _ = try self.addInst(.{
        .tag = .pseudo,
        .ops = ops,
        .data = .{ .rr = .{ .r1 = reg1, .r2 = reg2 } },
    });
}

fn asmPseudoRegisterImmediate(self: *CodeGen, ops: Mir.Inst.Ops, reg: Register, imm: Immediate) !void {
    assert(std.mem.startsWith(u8, @tagName(ops), "pseudo_") and
        std.mem.endsWith(u8, @tagName(ops), "_ri_s"));
    _ = try self.addInst(.{
        .tag = .pseudo,
        .ops = ops,
        .data = .{ .ri = .{ .r1 = reg, .i = @bitCast(imm.signed) } },
    });
}

fn asmRegister(self: *CodeGen, tag: Mir.Inst.FixedTag, reg: Register) !void {
    _ = try self.addInst(.{
        .tag = tag[1],
        .ops = .r,
        .data = .{ .r = .{
            .fixes = tag[0],
            .r1 = reg,
        } },
    });
}

fn asmImmediate(self: *CodeGen, tag: Mir.Inst.FixedTag, imm: Immediate) !void {
    _ = try self.addInst(.{
        .tag = tag[1],
        .ops = switch (imm) {
            .signed => .i_s,
            .unsigned => .i_u,
            .nav => .nav,
            .uav => .uav,
            .lazy_sym => .lazy_sym,
            .extern_func => .extern_func,
        },
        .data = switch (imm) {
            .signed, .unsigned => .{ .i = .{
                .fixes = tag[0],
                .i = switch (imm) {
                    .signed => |s| @bitCast(s),
                    .unsigned => |u| @intCast(u),
                    .nav, .uav, .lazy_sym, .extern_func => unreachable,
                },
            } },
            .nav => |nav| switch (tag[0]) {
                ._ => .{ .nav = nav },
                else => unreachable,
            },
            .uav => |uav| switch (tag[0]) {
                ._ => .{ .uav = uav },
                else => unreachable,
            },
            .lazy_sym => |lazy_sym| switch (tag[0]) {
                ._ => .{ .lazy_sym = lazy_sym },
                else => unreachable,
            },
            .extern_func => |extern_func| switch (tag[0]) {
                ._ => .{ .extern_func = extern_func },
                else => unreachable,
            },
        },
    });
}

fn asmImmediateRegister(self: *CodeGen, tag: Mir.Inst.FixedTag, imm: Immediate, reg: Register) !void {
    _ = try self.addInst(.{
        .tag = tag[1],
        .ops = .ir,
        .data = .{ .ri = .{
            .fixes = tag[0],
            .r1 = reg,
            .i = @as(u8, switch (imm) {
                .signed => |s| @bitCast(@as(i8, @intCast(s))),
                .unsigned => |u| @intCast(u),
                .nav, .uav, .lazy_sym, .extern_func => unreachable,
            }),
        } },
    });
}

fn asmImmediateImmediate(self: *CodeGen, tag: Mir.Inst.FixedTag, imm1: Immediate, imm2: Immediate) !void {
    _ = try self.addInst(.{
        .tag = tag[1],
        .ops = .ii,
        .data = .{ .ii = .{
            .fixes = tag[0],
            .i1 = switch (imm1) {
                .signed => |s| @bitCast(@as(i16, @intCast(s))),
                .unsigned => |u| @intCast(u),
                .nav, .uav, .lazy_sym, .extern_func => unreachable,
            },
            .i2 = switch (imm2) {
                .signed => |s| @bitCast(@as(i8, @intCast(s))),
                .unsigned => |u| @intCast(u),
                .nav, .uav, .lazy_sym, .extern_func => unreachable,
            },
        } },
    });
}

fn asmRegisterRegister(self: *CodeGen, tag: Mir.Inst.FixedTag, reg1: Register, reg2: Register) !void {
    _ = try self.addInst(.{
        .tag = tag[1],
        .ops = .rr,
        .data = .{ .rr = .{
            .fixes = tag[0],
            .r1 = reg1,
            .r2 = reg2,
        } },
    });
}

fn asmRegisterImmediate(self: *CodeGen, tag: Mir.Inst.FixedTag, reg: Register, imm: Immediate) !void {
    const ops: Mir.Inst.Ops, const i: u32 = switch (imm) {
        .signed => |s| .{ .ri_s, @bitCast(s) },
        .unsigned => |u| if (std.math.cast(u32, u)) |small|
            .{ .ri_u, small }
        else
            .{ .ri_64, try self.addExtra(Mir.Imm64.encode(imm.unsigned)) },
        .nav, .uav, .lazy_sym, .extern_func => unreachable,
    };
    _ = try self.addInst(.{
        .tag = tag[1],
        .ops = ops,
        .data = .{ .ri = .{
            .fixes = tag[0],
            .r1 = reg,
            .i = i,
        } },
    });
}

fn asmRegisterRegisterRegister(
    self: *CodeGen,
    tag: Mir.Inst.FixedTag,
    reg1: Register,
    reg2: Register,
    reg3: Register,
) !void {
    _ = try self.addInst(.{
        .tag = tag[1],
        .ops = .rrr,
        .data = .{ .rrr = .{
            .fixes = tag[0],
            .r1 = reg1,
            .r2 = reg2,
            .r3 = reg3,
        } },
    });
}

fn asmRegisterRegisterRegisterRegister(
    self: *CodeGen,
    tag: Mir.Inst.FixedTag,
    reg1: Register,
    reg2: Register,
    reg3: Register,
    reg4: Register,
) !void {
    _ = try self.addInst(.{
        .tag = tag[1],
        .ops = .rrrr,
        .data = .{ .rrrr = .{
            .fixes = tag[0],
            .r1 = reg1,
            .r2 = reg2,
            .r3 = reg3,
            .r4 = reg4,
        } },
    });
}

fn asmRegisterRegisterRegisterImmediate(
    self: *CodeGen,
    tag: Mir.Inst.FixedTag,
    reg1: Register,
    reg2: Register,
    reg3: Register,
    imm: Immediate,
) !void {
    _ = try self.addInst(.{
        .tag = tag[1],
        .ops = .rrri,
        .data = .{ .rrri = .{
            .fixes = tag[0],
            .r1 = reg1,
            .r2 = reg2,
            .r3 = reg3,
            .i = switch (imm) {
                .signed => |s| @bitCast(@as(i8, @intCast(s))),
                .unsigned => |u| @intCast(u),
                .nav, .uav, .lazy_sym, .extern_func => unreachable,
            },
        } },
    });
}

fn asmRegisterRegisterImmediate(
    self: *CodeGen,
    tag: Mir.Inst.FixedTag,
    reg1: Register,
    reg2: Register,
    imm: Immediate,
) !void {
    _ = try self.addInst(.{
        .tag = tag[1],
        .ops = switch (imm) {
            .signed => .rri_s,
            .unsigned => .rri_u,
            .nav, .uav, .lazy_sym, .extern_func => unreachable,
        },
        .data = .{ .rri = .{
            .fixes = tag[0],
            .r1 = reg1,
            .r2 = reg2,
            .i = switch (imm) {
                .signed => |s| @bitCast(s),
                .unsigned => |u| @intCast(u),
                .nav, .uav, .lazy_sym, .extern_func => unreachable,
            },
        } },
    });
}

fn asmRegisterRegisterMemory(
    self: *CodeGen,
    tag: Mir.Inst.FixedTag,
    reg1: Register,
    reg2: Register,
    m: Memory,
) !void {
    _ = try self.addInst(.{
        .tag = tag[1],
        .ops = .rrm,
        .data = .{ .rrx = .{
            .fixes = tag[0],
            .r1 = reg1,
            .r2 = reg2,
            .payload = try self.addExtra(Mir.Memory.encode(m)),
        } },
    });
}

fn asmRegisterRegisterMemoryRegister(
    self: *CodeGen,
    tag: Mir.Inst.FixedTag,
    reg1: Register,
    reg2: Register,
    m: Memory,
    reg3: Register,
) !void {
    _ = try self.addInst(.{
        .tag = tag[1],
        .ops = .rrmr,
        .data = .{ .rrrx = .{
            .fixes = tag[0],
            .r1 = reg1,
            .r2 = reg2,
            .r3 = reg3,
            .payload = try self.addExtra(Mir.Memory.encode(m)),
        } },
    });
}

fn asmMemory(self: *CodeGen, tag: Mir.Inst.FixedTag, m: Memory) !void {
    _ = try self.addInst(.{
        .tag = tag[1],
        .ops = .m,
        .data = .{ .x = .{
            .fixes = tag[0],
            .payload = try self.addExtra(Mir.Memory.encode(m)),
        } },
    });
}

fn asmRegisterMemory(self: *CodeGen, tag: Mir.Inst.FixedTag, reg: Register, m: Memory) !void {
    _ = try self.addInst(.{
        .tag = tag[1],
        .ops = .rm,
        .data = .{ .rx = .{
            .fixes = tag[0],
            .r1 = reg,
            .payload = try self.addExtra(Mir.Memory.encode(m)),
        } },
    });
}

fn asmRegisterMemoryRegister(
    self: *CodeGen,
    tag: Mir.Inst.FixedTag,
    reg1: Register,
    m: Memory,
    reg2: Register,
) !void {
    _ = try self.addInst(.{
        .tag = tag[1],
        .ops = .rmr,
        .data = .{ .rrx = .{
            .fixes = tag[0],
            .r1 = reg1,
            .r2 = reg2,
            .payload = try self.addExtra(Mir.Memory.encode(m)),
        } },
    });
}

fn asmRegisterMemoryImmediate(
    self: *CodeGen,
    tag: Mir.Inst.FixedTag,
    reg: Register,
    m: Memory,
    imm: Immediate,
) !void {
    if (switch (imm) {
        .signed => |s| if (std.math.cast(i16, s)) |x| @as(u16, @bitCast(x)) else null,
        .unsigned => |u| std.math.cast(u16, u),
        .nav, .uav, .lazy_sym, .extern_func => unreachable,
    }) |small_imm| {
        _ = try self.addInst(.{
            .tag = tag[1],
            .ops = .rmi,
            .data = .{ .rix = .{
                .fixes = tag[0],
                .r1 = reg,
                .i = small_imm,
                .payload = try self.addExtra(Mir.Memory.encode(m)),
            } },
        });
    } else {
        const payload = try self.addExtra(Mir.Imm32{ .imm = switch (imm) {
            .signed => |s| @bitCast(s),
            .unsigned => |u| @as(u32, @intCast(u)),
            .nav, .uav, .lazy_sym, .extern_func => unreachable,
        } });
        assert(payload + 1 == try self.addExtra(Mir.Memory.encode(m)));
        _ = try self.addInst(.{
            .tag = tag[1],
            .ops = switch (imm) {
                .signed => .rmi_s,
                .unsigned => .rmi_u,
                .nav, .uav, .lazy_sym, .extern_func => unreachable,
            },
            .data = .{ .rx = .{
                .fixes = tag[0],
                .r1 = reg,
                .payload = payload,
            } },
        });
    }
}

fn asmRegisterRegisterMemoryImmediate(
    self: *CodeGen,
    tag: Mir.Inst.FixedTag,
    reg1: Register,
    reg2: Register,
    m: Memory,
    imm: Immediate,
) !void {
    _ = try self.addInst(.{
        .tag = tag[1],
        .ops = .rrmi,
        .data = .{ .rrix = .{
            .fixes = tag[0],
            .r1 = reg1,
            .r2 = reg2,
            .i = @intCast(imm.unsigned),
            .payload = try self.addExtra(Mir.Memory.encode(m)),
        } },
    });
}

fn asmMemoryRegister(self: *CodeGen, tag: Mir.Inst.FixedTag, m: Memory, reg: Register) !void {
    _ = try self.addInst(.{
        .tag = tag[1],
        .ops = .mr,
        .data = .{ .rx = .{
            .fixes = tag[0],
            .r1 = reg,
            .payload = try self.addExtra(Mir.Memory.encode(m)),
        } },
    });
}

fn asmMemoryImmediate(self: *CodeGen, tag: Mir.Inst.FixedTag, m: Memory, imm: Immediate) !void {
    const payload = try self.addExtra(Mir.Imm32{ .imm = switch (imm) {
        .signed => |s| @bitCast(s),
        .unsigned => |u| @intCast(u),
        .nav, .uav, .lazy_sym, .extern_func => unreachable,
    } });
    assert(payload + 1 == try self.addExtra(Mir.Memory.encode(m)));
    _ = try self.addInst(.{
        .tag = tag[1],
        .ops = switch (imm) {
            .signed => .mi_s,
            .unsigned => .mi_u,
            .nav, .uav, .lazy_sym, .extern_func => unreachable,
        },
        .data = .{ .x = .{
            .fixes = tag[0],
            .payload = payload,
        } },
    });
}

fn asmMemoryRegisterRegister(
    self: *CodeGen,
    tag: Mir.Inst.FixedTag,
    m: Memory,
    reg1: Register,
    reg2: Register,
) !void {
    _ = try self.addInst(.{
        .tag = tag[1],
        .ops = .mrr,
        .data = .{ .rrx = .{
            .fixes = tag[0],
            .r1 = reg1,
            .r2 = reg2,
            .payload = try self.addExtra(Mir.Memory.encode(m)),
        } },
    });
}

fn asmMemoryRegisterImmediate(
    self: *CodeGen,
    tag: Mir.Inst.FixedTag,
    m: Memory,
    reg: Register,
    imm: Immediate,
) !void {
    _ = try self.addInst(.{
        .tag = tag[1],
        .ops = .mri,
        .data = .{ .rix = .{
            .fixes = tag[0],
            .r1 = reg,
            .i = @intCast(imm.unsigned),
            .payload = try self.addExtra(Mir.Memory.encode(m)),
        } },
    });
}

fn gen(
    self: *CodeGen,
    zir: *const std.zig.Zir,
    func_zir_inst: std.zig.Zir.Inst.Index,
    comptime_args: InternPool.Index.Slice,
    air_arg_count: u32,
) InnerError!void {
    const pt = self.pt;
    const zcu = pt.zcu;
    const fn_info = zcu.typeToFunc(self.fn_type).?;
    if (fn_info.cc != .naked) {
        try self.asmRegister(.{ ._, .push }, .rbp);
        try self.asmPseudoImmediate(.pseudo_cfi_adjust_cfa_offset_i_s, .s(8));
        try self.asmPseudoRegisterImmediate(.pseudo_cfi_rel_offset_ri_s, .rbp, .s(0));
        try self.asmRegisterRegister(.{ ._, .mov }, .rbp, .rsp);
        try self.asmPseudoRegister(.pseudo_cfi_def_cfa_register_r, .rbp);
        const backpatch_push_callee_preserved_regs = try self.asmPlaceholder();
        const backpatch_frame_align = try self.asmPlaceholder();
        const backpatch_frame_align_extra = try self.asmPlaceholder();
        const backpatch_stack_alloc = try self.asmPlaceholder();
        const backpatch_stack_alloc_extra = try self.asmPlaceholder();

        switch (self.ret_mcv.long) {
            .none, .unreach => {},
            .indirect => {
                // The address where to store the return value for the caller is in a
                // register which the callee is free to clobber. Therefore, we purposely
                // spill it to stack immediately.
                const frame_index = try self.allocFrameIndex(.initSpill(.usize, zcu));
                try self.genSetMem(
                    .{ .frame = frame_index },
                    0,
                    .usize,
                    self.ret_mcv.long.address().offset(-self.ret_mcv.short.indirect.off),
                    .{},
                );
                self.ret_mcv.long = .{ .load_frame = .{ .index = frame_index } };
                tracking_log.debug("spill {f} to {f}", .{ self.ret_mcv.long, frame_index });
            },
            else => unreachable,
        }

        if (fn_info.is_var_args) switch (fn_info.cc) {
            .x86_64_sysv => {
                const info = &self.va_info.sysv;
                const reg_save_area_fi = try self.allocFrameIndex(.init(.{
                    .size = abi.SysV.c_abi_int_param_regs.len * 8 +
                        abi.SysV.c_abi_sse_param_regs.len * 16,
                    .alignment = .@"16",
                }));
                info.reg_save_area = .{ .index = reg_save_area_fi };

                for (abi.SysV.c_abi_int_param_regs[info.gp_count..], info.gp_count..) |reg, reg_i|
                    try self.genSetMem(.{ .frame = reg_save_area_fi }, @intCast(reg_i * 8), .usize, .{ .register = reg }, .{});

                try self.asmRegisterImmediate(.{ ._, .cmp }, .al, .u(info.fp_count));
                const skip_sse_reloc = try self.asmJccReloc(.na, undefined);

                const vec_2_f64 = try pt.vectorType(.{ .len = 2, .child = .f64_type });
                for (abi.SysV.c_abi_sse_param_regs[info.fp_count..], info.fp_count..) |reg, reg_i|
                    try self.genSetMem(
                        .{ .frame = reg_save_area_fi },
                        @intCast(abi.SysV.c_abi_int_param_regs.len * 8 + reg_i * 16),
                        vec_2_f64,
                        .{ .register = reg },
                        .{},
                    );

                self.performReloc(skip_sse_reloc);
            },
            .x86_64_win => return self.fail("TODO implement gen var arg function for Win64", .{}),
            else => |cc| return self.fail("{s} does not support var args", .{@tagName(cc)}),
        };

        if (!self.mod.strip) try self.asmPseudo(.pseudo_dbg_prologue_end_none);

        try self.genMainBody(zir, func_zir_inst, comptime_args, air_arg_count);

        const epilogue = if (self.epilogue_relocs.items.len > 0) epilogue: {
            var last_inst: Mir.Inst.Index = @intCast(self.mir_instructions.len - 1);
            while (self.epilogue_relocs.getLastOrNull() == last_inst) {
                self.epilogue_relocs.items.len -= 1;
                self.mir_instructions.set(last_inst, .{
                    .tag = .pseudo,
                    .ops = .pseudo_dead_none,
                    .data = undefined,
                });
                last_inst -= 1;
            }
            for (self.epilogue_relocs.items) |epilogue_reloc| self.performReloc(epilogue_reloc);

            if (!self.mod.strip) try self.asmPseudo(.pseudo_dbg_epilogue_begin_none);
            const backpatch_stack_dealloc = try self.asmPlaceholder();
            const backpatch_pop_callee_preserved_regs = try self.asmPlaceholder();
            try self.asmRegister(.{ ._, .pop }, .rbp);
            try self.asmPseudoRegisterImmediate(.pseudo_cfi_def_cfa_ri_s, .rsp, .s(8));
            try self.asmOpOnly(.{ ._, .ret });
            break :epilogue .{
                .backpatch_stack_dealloc = backpatch_stack_dealloc,
                .backpatch_pop_callee_preserved_regs = backpatch_pop_callee_preserved_regs,
            };
        } else null;

        const frame_layout = try self.computeFrameLayout(fn_info.cc);
        const need_frame_align = frame_layout.stack_mask != std.math.maxInt(u32);
        const need_stack_adjust = frame_layout.stack_adjust > 0;
        const need_save_reg = frame_layout.save_reg_list.count() > 0;
        if (need_frame_align) {
            const page_align = @as(u32, std.math.maxInt(u32)) << 12;
            self.mir_instructions.set(backpatch_frame_align, .{
                .tag = .@"and",
                .ops = .ri_s,
                .data = .{ .ri = .{
                    .r1 = .rsp,
                    .i = @max(frame_layout.stack_mask, page_align),
                } },
            });
            if (frame_layout.stack_mask < page_align) {
                self.mir_instructions.set(backpatch_frame_align_extra, .{
                    .tag = .pseudo,
                    .ops = .pseudo_probe_align_ri_s,
                    .data = .{ .ri = .{
                        .r1 = .rsp,
                        .i = ~frame_layout.stack_mask & page_align,
                    } },
                });
            }
        }
        if (need_stack_adjust) {
            const page_size: u32 = 1 << 12;
            if (frame_layout.stack_adjust <= page_size) {
                self.mir_instructions.set(backpatch_stack_alloc, .{
                    .tag = .sub,
                    .ops = .ri_s,
                    .data = .{ .ri = .{
                        .r1 = .rsp,
                        .i = frame_layout.stack_adjust,
                    } },
                });
            } else if (frame_layout.stack_adjust <
                page_size * Lower.pseudo_probe_adjust_unrolled_max_insts)
            {
                self.mir_instructions.set(backpatch_stack_alloc, .{
                    .tag = .pseudo,
                    .ops = .pseudo_probe_adjust_unrolled_ri_s,
                    .data = .{ .ri = .{
                        .r1 = .rsp,
                        .i = frame_layout.stack_adjust,
                    } },
                });
            } else {
                const scratch_reg = abi.getCAbiLinkerScratchReg(fn_info.cc);
                self.mir_instructions.set(backpatch_stack_alloc, .{
                    .tag = .pseudo,
                    .ops = .pseudo_probe_adjust_setup_rri_s,
                    .data = .{ .rri = .{
                        .r1 = .rsp,
                        .r2 = scratch_reg,
                        .i = frame_layout.stack_adjust,
                    } },
                });
                self.mir_instructions.set(backpatch_stack_alloc_extra, .{
                    .tag = .pseudo,
                    .ops = .pseudo_probe_adjust_loop_rr,
                    .data = .{ .rr = .{
                        .r1 = .rsp,
                        .r2 = scratch_reg,
                    } },
                });
            }
        }
        if (epilogue) |e| if (need_frame_align or need_stack_adjust) {
            self.mir_instructions.set(e.backpatch_stack_dealloc, switch (-frame_layout.save_reg_list.size(self.target)) {
                0 => .{
                    .tag = .mov,
                    .ops = .rr,
                    .data = .{ .rr = .{
                        .r1 = .rsp,
                        .r2 = .rbp,
                    } },
                },
                else => |disp| .{
                    .tag = .lea,
                    .ops = .rm,
                    .data = .{ .rx = .{
                        .r1 = .rsp,
                        .payload = try self.addExtra(Mir.Memory.encode(.{
                            .base = .{ .reg = .rbp },
                            .mod = .{ .rm = .{
                                .size = .qword,
                                .disp = disp,
                            } },
                        })),
                    } },
                },
            });
        };
        if (need_save_reg) {
            self.mir_instructions.set(backpatch_push_callee_preserved_regs, .{
                .tag = .pseudo,
                .ops = .pseudo_push_reg_list,
                .data = .{ .reg_list = frame_layout.save_reg_list },
            });
            if (epilogue) |e| self.mir_instructions.set(e.backpatch_pop_callee_preserved_regs, .{
                .tag = .pseudo,
                .ops = .pseudo_pop_reg_list,
                .data = .{ .reg_list = frame_layout.save_reg_list },
            });
        }
    } else {
        if (!self.mod.strip) try self.asmPseudo(.pseudo_dbg_prologue_end_none);
        try self.genMainBody(zir, func_zir_inst, comptime_args, air_arg_count);
        if (!self.mod.strip) try self.asmPseudo(.pseudo_dbg_epilogue_begin_none);
    }
}

fn genMainBody(
    cg: *CodeGen,
    zir: *const std.zig.Zir,
    func_zir_inst: std.zig.Zir.Inst.Index,
    comptime_args: InternPool.Index.Slice,
    air_arg_count: u32,
) InnerError!void {
    const pt = cg.pt;
    const zcu = pt.zcu;
    const ip = &zcu.intern_pool;

    const main_body = cg.air.getMainBody();
    const air_args_body = main_body[0..air_arg_count];
    try cg.genBody(air_args_body);

    if (!cg.mod.strip) {
        var air_arg_index: usize = 0;
        const fn_info = zcu.typeToFunc(cg.fn_type).?;
        var fn_param_index: usize = 0;
        var zir_param_index: usize = 0;
        for (zir.getParamBody(func_zir_inst)) |zir_param_inst| {
            const name = switch (zir.getParamName(zir_param_inst) orelse break) {
                .empty => .none,
                else => |zir_name| try cg.addString(zir.nullTerminatedString(zir_name)),
            };
            defer zir_param_index += 1;

            if (comptime_args.len > 0) switch (comptime_args.get(ip)[zir_param_index]) {
                .none => {},
                else => |comptime_arg| {
                    try cg.mir_locals.append(cg.gpa, .{ .name = name, .type = ip.typeOf(comptime_arg) });
                    _ = try cg.addInst(.{
                        .tag = .pseudo,
                        .ops = .pseudo_dbg_arg_val,
                        .data = .{ .ip_index = comptime_arg },
                    });
                    continue;
                },
            };

            const arg_ty = fn_info.param_types.get(ip)[fn_param_index];
            try cg.mir_locals.append(cg.gpa, .{ .name = name, .type = arg_ty });
            fn_param_index += 1;

            if (air_arg_index == air_args_body.len) {
                try cg.asmPseudo(.pseudo_dbg_arg_none);
                continue;
            }
            const air_arg_inst = air_args_body[air_arg_index];
            const air_arg_data = cg.air.instructions.items(.data)[air_arg_index].arg;
            if (air_arg_data.zir_param_index != zir_param_index) {
                try cg.asmPseudo(.pseudo_dbg_arg_none);
                continue;
            }
            air_arg_index += 1;
            try cg.genLocalDebugInfo(
                .arg,
                .fromInterned(arg_ty),
                cg.getResolvedInstValue(air_arg_inst).short,
            );
        }
        if (fn_info.is_var_args) try cg.asmPseudo(.pseudo_dbg_var_args_none);
    }

    try cg.genBody(main_body[air_arg_count..]);
}

fn checkInvariantsAfterAirInst(cg: *CodeGen) void {
    assert(!cg.register_manager.lockedRegsExist());

    if (std.debug.runtime_safety) {
        // check consistency of tracked registers
        var it = cg.register_manager.free_registers.iterator(.{ .kind = .unset });
        while (it.next()) |index| {
            const tracked_inst = cg.register_manager.registers[index];
            const tracking = cg.getResolvedInstValue(tracked_inst);
            for (tracking.getRegs()) |reg| {
                if (RegisterManager.indexOfRegIntoTracked(reg).? == index) break;
            } else unreachable; // tracked register not in use
        }
    }
}

fn genBodyBlock(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
    if (!cg.mod.strip) try cg.asmPseudo(.pseudo_dbg_enter_block_none);
    try cg.genBody(body);
    if (!cg.mod.strip) try cg.asmPseudo(.pseudo_dbg_leave_block_none);
}

fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
    @setEvalBranchQuota(31_000);
    const pt = cg.pt;
    const zcu = pt.zcu;
    const ip = &zcu.intern_pool;
    const air_tags = cg.air.instructions.items(.tag);
    const air_datas = cg.air.instructions.items(.data);

    for (body) |inst| {
        if (cg.liveness.isUnused(inst) and !cg.air.mustLower(inst, ip)) continue;
        wip_mir_log.debug("{f}", .{cg.fmtAir(inst)});
        verbose_tracking_log.debug("{f}", .{cg.fmtTracking()});

        cg.reused_operands = .initEmpty();
        try cg.inst_tracking.ensureUnusedCapacity(cg.gpa, 1);
        switch (air_tags[@intFromEnum(inst)]) {
            .select => try cg.airSelect(inst),
            .shuffle_one, .shuffle_two => @panic("x86_64 TODO: shuffle_one/shuffle_two"),

            .arg => try cg.airArg(inst),
            .add, .add_optimized, .add_wrap => |air_tag| {
                const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                var res: [1]Temp = undefined;
                cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{
                    .src_constraints = .{ .{ .int = .byte }, .{ .int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .imm8, .none } },
                        .{ .src = .{ .imm8, .mut_mem, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                        .{ .src = .{ .imm8, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .mut_mem, .to_gpr, .none } },
                        .{ .src = .{ .to_gpr, .mut_mem, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0b, .src1b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .int = .word }, .{ .int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .imm16, .none } },
                        .{ .src = .{ .imm16, .mut_mem, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .mut_mem, .to_gpr, .none } },
                        .{ .src = .{ .to_gpr, .mut_mem, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0w, .src1w, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .int = .dword }, .{ .int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .imm32, .none } },
                        .{ .src = .{ .imm32, .mut_mem, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .imm32, .none } },
                        .{ .src = .{ .imm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .mut_mem, .to_gpr, .none } },
                        .{ .src = .{ .to_gpr, .mut_mem, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0d, .src1d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .int = .qword }, .{ .int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .simm32, .none } },
                        .{ .src = .{ .simm32, .mut_mem, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .simm32, .none } },
                        .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .mut_mem, .to_gpr, .none } },
                        .{ .src = .{ .to_gpr, .mut_mem, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0q, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_int = .{ .of = .qword, .is = .qword } },
                        .{ .remainder_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp1q, .memsia(.src1q, .@"8", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_size), .tmp1q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .remainder_int = .{ .of = .dword, .is = .dword } },
                        .{ .remainder_int = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_4), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp1d, .memsia(.src1d, .@"4", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_size), .tmp1d, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_int = .{ .of = .xword, .is = .byte } },
                        .{ .scalar_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_b, .add, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_int = .{ .of = .xword, .is = .byte } },
                        .{ .scalar_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_b, .add, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_int = .{ .of = .yword, .is = .byte } },
                        .{ .scalar_int = .{ .of = .yword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_b, .add, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .yword, .is = .byte } },
                        .{ .multiple_scalar_int = .{ .of = .yword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_b, .add, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .byte } },
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_b, .add, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .byte } },
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_b, .add, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_int = .{ .of = .xword, .is = .word } },
                        .{ .scalar_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .add, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_int = .{ .of = .xword, .is = .word } },
                        .{ .scalar_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_w, .add, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_int = .{ .of = .yword, .is = .word } },
                        .{ .scalar_int = .{ .of = .yword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .add, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .yword, .is = .word } },
                        .{ .multiple_scalar_int = .{ .of = .yword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .add, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .word } },
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .add, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .word } },
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_w, .add, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_int = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_int = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .add, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_int = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_d, .add, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_int = .{ .of = .yword, .is = .dword } },
                        .{ .scalar_int = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .add, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .yword, .is = .dword } },
                        .{ .multiple_scalar_int = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_d, .add, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } },
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_d, .add, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } },
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_d, .add, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } },
                        .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_int = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_q, .add, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_int = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_q, .add, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_int = .{ .of = .yword, .is = .qword } },
                        .{ .scalar_int = .{ .of = .yword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_q, .add, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .yword, .is = .qword } },
                        .{ .multiple_scalar_int = .{ .of = .yword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_q, .add, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } },
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_q, .add, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } },
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_q, .add, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memia(.src1, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .memia(.dst0, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp4p, .sa(.src0, .sub_elem_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp5q, .leasi(.tmp1q, .@"8", .tmp4), ._, ._ },
                        .{ ._, ._, .adc, .tmp5q, .leasi(.tmp2q, .@"8", .tmp4), ._, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp3q, .@"8", .tmp4), .tmp5q, ._, ._ },
                        .{ ._, ._c, .in, .tmp4p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .scalar_remainder_int = .{ .of = .dword, .is = .dword } },
                        .{ .scalar_remainder_int = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memia(.src1, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .memia(.dst0, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp4p, .sa(.src0, .sub_elem_size_div_4), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp5d, .leasi(.tmp1d, .@"4", .tmp4), ._, ._ },
                        .{ ._, ._, .adc, .tmp5d, .leasi(.tmp2d, .@"4", .tmp4), ._, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp3d, .@"4", .tmp4), .tmp5d, ._, ._ },
                        .{ ._, ._c, .in, .tmp4p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
                        .{ ._, .v_ss, .add, .dst0x, .dst0x, .tmp0d, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .word } },
                        .{ .scalar_float = .{ .of = .qword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_4_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
                        .{ ._, .v_ps, .add, .dst0x, .dst0x, .tmp0x, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .word } },
                        .{ .scalar_float = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ },
                        .{ ._, .v_ps, .add, .dst0y, .dst0y, .tmp0y, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_ps, .add, .tmp1y, .tmp1y, .tmp2y, ._ },
                        .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ },
                        .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
                        .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0) },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                        .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                        .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .tmp4d, .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ss, .add, .dst0x, .src0x, .src1d, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._ss, .add, .dst0x, .src1d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .add, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._ps, .add, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .yword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .add, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_ps, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_ps, .add, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._ps, .add, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_sd, .add, .dst0x, .src0x, .src1q, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._sd, .add, .dst0x, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f64, .kind = .{ .reg = .st6 } },
                        .{ .type = .f64, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0q, ._, ._, ._ },
                        .{ ._, .f_, .add, .src1q, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_pd, .add, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._pd, .add, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .yword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .yword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_pd, .add, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_pd, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_pd, .add, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._pd, .add, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .reg = .st6 } },
                        .{ .type = .f64, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, .f_, .add, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, .f_p, .st, .memia(.dst0q, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
                        .{ ._, .f_p, .add, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .msvc,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
                        .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp3d, .memd(.tmp2b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_00_11), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp2b, 1), .tmp3b, ._, ._ },
                        .{ ._, .f_p, .add, ._, ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .mem, .to_x87, .none } },
                        .{ .src = .{ .to_x87, .to_x87, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .f_, .add, .tmp0t, .src1t, ._, ._ },
                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .msvc,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .mem, .to_x87, .none } },
                        .{ .src = .{ .to_x87, .to_x87, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_00_11), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
                        .{ ._, .f_, .add, .tmp0t, .src1t, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, .f_p, .add, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .msvc,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .fn_cw, .st, .tmp0w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp1d, .memd(.tmp0b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp0b, 1), .ui(0b000_0_00_11), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp0b, 1), .tmp1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp1, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, .f_, .ld, .memia(.src1t, .tmp1, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, .f_p, .add, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .memia(.dst0t, .tmp1, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp2x, .memi(.src1x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .memi(.src1x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._ps, .mova, .tmp2x, .memi(.src1x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memi(.src1, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp4x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memi(.src1, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp4x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memi(.src1, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp4x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f} {f}", .{
                        @tagName(air_tag),
                        cg.typeOf(bin_op.lhs).fmt(pt),
                        ops[0].tracking(cg),
                        ops[1].tracking(cg),
                    }),
                    else => |e| return e,
                };
                switch (air_tag) {
                    else => unreachable,
                    .add, .add_optimized => {},
                    .add_wrap => res[0].wrapInt(cg) catch |err| switch (err) {
                        error.SelectFailed => return cg.fail("failed to select {s} wrap {f} {f}", .{
                            @tagName(air_tag),
                            cg.typeOf(bin_op.lhs).fmt(pt),
                            res[0].tracking(cg),
                        }),
                        else => |e| return e,
                    },
                }
                try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
            },
            .add_safe => unreachable,
            .add_sat => |air_tag| {
                const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                var res: [1]Temp = undefined;
                cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{
                    .src_constraints = .{ .{ .exact_int = 1 }, .{ .exact_int = 1 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                        .{ .src = .{ .imm8, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .@"or", .dst0b, .src1b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 8 }, .{ .exact_signed_int = 8 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                        .{ .src = .{ .imm8, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0b, .ui(7), ._, ._ },
                        .{ ._, ._, .xor, .tmp0b, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .add, .dst0b, .src1b, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_signed_int = 8 }, .{ .exact_signed_int = 8 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                        .{ .src = .{ .imm8, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0b, .src1b, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0b, .ui(7), ._, ._ },
                        .{ ._, ._, .xor, .dst0b, .sa(.src0, .add_smin), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                        .{ .src = .{ .imm8, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0b, .ui(7), ._, ._ },
                        .{ ._, ._, .add, .dst0b, .src1b, ._, ._ },
                        .{ ._, ._, .xor, .tmp0b, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .@"test", .dst0b, .sia(-1 << 7, .src0, .sub_smin), ._, ._ },
                        .{ ._, ._po, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                        .{ .src = .{ .imm8, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0b, .src1b, ._, ._ },
                        .{ ._, ._, .@"test", .dst0b, .sia(-1 << 7, .src0, .sub_smin), ._, ._ },
                        .{ ._, ._pe, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0b, .ui(7), ._, ._ },
                        .{ ._, ._, .xor, .dst0b, .sa(.src0, .add_smax), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_unsigned_int = 8 }, .{ .exact_unsigned_int = 8 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                        .{ .src = .{ .imm8, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u8, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0b, .src1b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .@"or", .dst0b, .tmp0b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                        .{ .src = .{ .imm8, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u8, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0b, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .cmp, .dst0b, .tmp0b, ._, ._ },
                        .{ ._, ._a, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                        .{ .src = .{ .imm8, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0b, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .dst0b, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0b, .ua(.src0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .fast_imm16, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 16 }, .{ .exact_signed_int = 16 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .tmp0w, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .add, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 16 }, .{ .exact_signed_int = 16 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .add, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 16 }, .{ .exact_signed_int = 16 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .dst0w, .sa(.src0, .add_smin), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_signed_int = 16 }, .{ .exact_signed_int = 16 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smin), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .fast_imm16, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 15 }, .{ .exact_signed_int = 15 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ },
                        .{ ._, ._, .add, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._, .xor, .tmp0w, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ },
                        .{ ._, ._, .add, .tmp1w, .tmp1w, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .fast_imm16, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 15 }, .{ .exact_signed_int = 15 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ },
                        .{ ._, ._, .add, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .xor, .tmp0w, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ },
                        .{ ._, ._, .add, .tmp1w, .tmp1w, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 15 }, .{ .exact_signed_int = 15 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ },
                        .{ ._, ._, .add, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ },
                        .{ ._, ._, .add, .tmp1w, .tmp1w, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 15 }, .{ .exact_signed_int = 15 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ },
                        .{ ._, ._, .add, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ },
                        .{ ._, ._, .add, .tmp1w, .tmp1w, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 15 }, .{ .exact_signed_int = 15 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._, .add, .tmp0w, .tmp0w, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .dst0w, .sa(.src0, .add_smax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 15 }, .{ .exact_signed_int = 15 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._, .add, .tmp0w, .tmp0w, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .dst0w, .sa(.src0, .add_smax), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_signed_int = 15 }, .{ .exact_signed_int = 15 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._, .add, .tmp0w, .tmp0w, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smax), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_signed_int = 15 }, .{ .exact_signed_int = 15 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._, .add, .tmp0w, .tmp0w, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi2, .cmov, .fast_imm16, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ },
                        .{ ._, ._, .add, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._, .xor, .tmp0w, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._rx, .ro, .tmp1d, .dst0d, .uia(1, .src0, .add_bit_size), ._ },
                        .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi2, .cmov, .fast_imm16, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ },
                        .{ ._, ._, .add, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .xor, .tmp0w, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._rx, .ro, .tmp1d, .dst0d, .uia(1, .src0, .add_bit_size), ._ },
                        .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi2, .cmov, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ },
                        .{ ._, ._, .add, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._rx, .ro, .tmp1d, .dst0d, .uia(1, .src0, .add_bit_size), ._ },
                        .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi2, .cmov, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ },
                        .{ ._, ._, .add, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._rx, .ro, .tmp1d, .dst0d, .uia(1, .src0, .add_bit_size), ._ },
                        .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .fast_imm16, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ },
                        .{ ._, ._, .add, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._, .xor, .tmp0w, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp1d, .uia(31, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .fast_imm16, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ },
                        .{ ._, ._, .add, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .xor, .tmp0w, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp1d, .uia(31, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ },
                        .{ ._, ._, .add, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp1d, .uia(31, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ },
                        .{ ._, ._, .add, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp1d, .uia(31, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0d, .uia(31, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .dst0w, .sa(.src0, .add_smax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0d, .uia(31, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .dst0w, .sa(.src0, .add_smax), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0d, .uia(31, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smax), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0d, .uia(31, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smax), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_unsigned_int = 16 }, .{ .exact_unsigned_int = 16 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._, .sbb, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .cmp, .dst0w, .tmp0w, ._, ._ },
                        .{ ._, ._a, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .cmp, .dst0w, .tmp0w, ._, ._ },
                        .{ ._, ._a, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._, .cmp, .dst0w, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0w, .ua(.src0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .cmp, .dst0w, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0w, .ua(.src0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._, .cmp, .dst0w, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .ua(.src0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .cmp, .dst0w, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .ua(.src0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 32 }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm32, .none } },
                        .{ .src = .{ .imm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .add, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_signed_int = 32 }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm32, .none } },
                        .{ .src = .{ .imm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smin), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 31 }, .{ .exact_signed_int = 31 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm32, .none } },
                        .{ .src = .{ .imm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0d, .ui(31), ._, ._ },
                        .{ ._, ._, .add, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ },
                        .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_signed_int = 31 }, .{ .exact_signed_int = 31 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm32, .none } },
                        .{ .src = .{ .imm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._, .add, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi2, .cmov, null, null },
                    .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm32, .none } },
                        .{ .src = .{ .imm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0d, .ui(31), ._, ._ },
                        .{ ._, ._, .add, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._rx, .ro, .tmp1d, .dst0d, .uia(1, .src0, .add_bit_size), ._ },
                        .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm32, .none } },
                        .{ .src = .{ .imm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0d, .ui(31), ._, ._ },
                        .{ ._, ._, .add, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp1d, .uia(31, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm32, .none } },
                        .{ .src = .{ .imm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0d, .uia(31, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smax), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .{ .exact_unsigned_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm32, .none } },
                        .{ .src = .{ .imm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm32, .none } },
                        .{ .src = .{ .imm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .cmp, .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._a, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm32, .none } },
                        .{ .src = .{ .imm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .cmp, .dst0d, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .ua(.src0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 64 }, .{ .exact_signed_int = 64 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .simm32, .none } },
                        .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .xor, .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .dst0q, .src1q, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0q, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 64 }, .{ .exact_signed_int = 64 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .simm32, .none } },
                        .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0q, .src1q, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .dst0q, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 63 }, .{ .exact_signed_int = 63 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .simm32, .none } },
                        .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .add, .dst0q, .src1q, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .xor, .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .dst0q, ._, ._ },
                        .{ ._, ._, .add, .tmp1q, .tmp1q, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0q, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 63 }, .{ .exact_signed_int = 63 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .simm32, .none } },
                        .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0q, .src1q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ },
                        .{ ._, ._, .add, .tmp0q, .tmp0q, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .xor, .dst0q, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, .cmov, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .simm32, .none } },
                        .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .add, .dst0q, .src1q, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .xor, .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._rx, .ro, .tmp1q, .dst0q, .sia(-31, .src0, .add_bit_size), ._ },
                        .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0q, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .simm32, .none } },
                        .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .add, .dst0q, .src1q, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .xor, .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .dst0q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp1q, .sia(-31, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0q, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .simm32, .none } },
                        .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0q, .src1q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0q, .sia(-31, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .xor, .dst0q, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .{ .exact_unsigned_int = 64 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .simm32, .none } },
                        .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0q, .src1q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp0q, .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .simm32, .none } },
                        .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0q, .src1q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .cmp, .dst0q, .tmp0q, ._, ._ },
                        .{ ._, ._a, .cmov, .dst0q, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .simm32, .none } },
                        .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0q, .src1q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .cmp, .dst0q, .tmp0q, ._, ._ },
                        .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0q, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .simm32, .none } },
                        .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0q, .src1q, ._, ._ },
                        .{ ._, ._, .cmp, .dst0q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0q, .ua(.src0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 128 } },
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 128 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .i64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp1q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp1q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp2q, ._, ._ },
                        .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 128 } },
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 128 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp1q, .memsia(.src1q, .@"8", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_size), .tmp1q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._nc, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .si(-1), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 64 } },
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .i64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(2, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -16), ._, ._ },
                        .{ ._, ._, .adc, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -16), .tmp1q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -16), ._, ._ },
                        .{ ._, ._, .adc, .tmp1q, .memad(.src1q, .add_size, -16), ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp2q, ._, ._ },
                        .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -16), .tmp1q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp1q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._nc, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .si(-1), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } },
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .i64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp1q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._l, .sa, .tmp1q, .uia(63, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .add, .tmp1q, .tmp1q, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp2q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp1q, ._, ._ },
                        .{ .@"0:", ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp2q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp2q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .cmp, .tmp2q, .tmp1q, ._, ._ },
                        .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp1q, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .si(-1), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } },
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .i64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp1q, .memsia(.src1q, .@"8", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_size), .tmp1q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._l, .sa, .tmp1q, .uia(63, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .add, .tmp1q, .tmp1q, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp2q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2q, .memsia(.src0q, .@"8", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp2q, .memsia(.src1q, .@"8", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_size), .tmp2q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .cmp, .tmp2q, .tmp1q, ._, ._ },
                        .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .si(-1), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .mmx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_int = .{ .of = .qword, .is = 1 } },
                        .{ .scalar_exact_int = .{ .of = .qword, .is = 1 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_mmx, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_mmx, .to_mmx, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_, .@"or", .dst0q, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_int = .{ .of = .xword, .is = 1 } },
                        .{ .scalar_exact_int = .{ .of = .xword, .is = 1 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_, .@"or", .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_int = .{ .of = .xword, .is = 1 } },
                        .{ .scalar_exact_int = .{ .of = .xword, .is = 1 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_, .@"or", .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_int = .{ .of = .xword, .is = 1 } },
                        .{ .scalar_exact_int = .{ .of = .xword, .is = 1 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._ps, .@"or", .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_int = .{ .of = .yword, .is = 1 } },
                        .{ .scalar_exact_int = .{ .of = .yword, .is = 1 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_, .@"or", .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .mmx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_signed_int = .{ .of = .qword, .is = 8 } },
                        .{ .scalar_exact_signed_int = .{ .of = .qword, .is = 8 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_mmx, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_mmx, .to_mmx, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_b, .adds, .dst0q, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 8 } },
                        .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 8 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_b, .adds, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 8 } },
                        .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 8 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_b, .adds, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_signed_int = .{ .of = .yword, .is = 8 } },
                        .{ .scalar_exact_signed_int = .{ .of = .yword, .is = 8 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_b, .adds, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_i8, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_16_i8, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_b, .add, .dst0x, .src0x, .src1x, ._ },
                        .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .lea(.tmp0x), ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                        .{ ._, .vp_b, .mins, .dst0x, .dst0x, .lea(.tmp0x), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_i8, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_16_i8, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_b, .add, .dst0x, .src1x, ._, ._ },
                        .{ ._, .p_b, .maxs, .dst0x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                        .{ ._, .p_b, .mins, .dst0x, .lea(.tmp0x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_i8, .kind = .{ .slimit_delta_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, .p_b, .sub, .dst0x, .tmp2x, ._, ._ },
                        .{ ._, .p_b, .adds, .dst0x, .src1x, ._, ._ },
                        .{ ._, .p_b, .add, .dst0x, .tmp2x, ._, ._ },
                        .{ ._, .p_b, .adds, .dst0x, .tmp2x, ._, ._ },
                        .{ ._, .p_b, .sub, .dst0x, .tmp2x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .yword, .is = .byte } },
                        .{ .scalar_signed_int = .{ .of = .yword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_32_i8, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .yword } } },
                        .{ .type = .vector_32_i8, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_b, .add, .dst0y, .src0y, .src1y, ._ },
                        .{ ._, .vp_b, .maxs, .dst0y, .dst0y, .lea(.tmp0y), ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                        .{ ._, .vp_b, .mins, .dst0y, .dst0y, .lea(.tmp0y), ._ },
                    } },
                }, .{
                    .required_features = .{ .mmx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_unsigned_int = .{ .of = .qword, .is = 8 } },
                        .{ .scalar_exact_unsigned_int = .{ .of = .qword, .is = 8 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_mmx, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_mmx, .to_mmx, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_b, .addus, .dst0q, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 8 } },
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 8 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_b, .addus, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 8 } },
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 8 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_b, .addus, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_unsigned_int = .{ .of = .yword, .is = 8 } },
                        .{ .scalar_exact_unsigned_int = .{ .of = .yword, .is = 8 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_b, .addus, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, .mmx, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } },
                        .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_mmx, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_mmx, .to_mmx, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_b, .add, .dst0x, .src1x, ._, ._ },
                        .{ ._, .p_b, .minu, .dst0x, .lea(.tmp0x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_b, .add, .dst0x, .src0x, .src1x, ._ },
                        .{ ._, .vp_b, .minu, .dst0x, .dst0x, .lea(.tmp0x), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_b, .add, .dst0x, .src1x, ._, ._ },
                        .{ ._, .p_b, .minu, .dst0x, .lea(.tmp0x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .yword, .is = .byte } },
                        .{ .scalar_unsigned_int = .{ .of = .yword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_32_u8, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .yword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_b, .add, .dst0y, .src0y, .src1y, ._ },
                        .{ ._, .vp_b, .minu, .dst0y, .dst0y, .lea(.tmp0y), ._ },
                    } },
                }, .{
                    .required_features = .{ .mmx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_signed_int = .{ .of = .qword, .is = 16 } },
                        .{ .scalar_exact_signed_int = .{ .of = .qword, .is = 16 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_mmx, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_mmx, .to_mmx, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_w, .adds, .dst0q, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 16 } },
                        .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 16 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .adds, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 16 } },
                        .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 16 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_w, .adds, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_signed_int = .{ .of = .yword, .is = 16 } },
                        .{ .scalar_exact_signed_int = .{ .of = .yword, .is = 16 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .adds, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, .mmx, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .word } },
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_mmx, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_mmx, .to_mmx, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i16, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .qword } } },
                        .{ .type = .vector_4_i16, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .qword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_w, .add, .dst0q, .src1q, ._, ._ },
                        .{ ._, .p_w, .maxs, .dst0q, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                        .{ ._, .p_w, .mins, .dst0q, .lea(.tmp0q), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .word } },
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i16, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_8_i16, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_w, .add, .dst0x, .src0x, .src1x, ._ },
                        .{ ._, .vp_w, .maxs, .dst0x, .dst0x, .lea(.tmp0x), ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                        .{ ._, .vp_w, .mins, .dst0x, .dst0x, .lea(.tmp0x), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .word } },
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i16, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_8_i16, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_w, .add, .dst0x, .src1x, ._, ._ },
                        .{ ._, .p_w, .maxs, .dst0x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                        .{ ._, .p_w, .mins, .dst0x, .lea(.tmp0x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .yword, .is = .word } },
                        .{ .scalar_signed_int = .{ .of = .yword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_i16, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .yword } } },
                        .{ .type = .vector_16_i16, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_w, .add, .dst0y, .src0y, .src1y, ._ },
                        .{ ._, .vp_w, .maxs, .dst0y, .dst0y, .lea(.tmp0y), ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                        .{ ._, .vp_w, .mins, .dst0y, .dst0y, .lea(.tmp0y), ._ },
                    } },
                }, .{
                    .required_features = .{ .mmx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_unsigned_int = .{ .of = .qword, .is = 16 } },
                        .{ .scalar_exact_unsigned_int = .{ .of = .qword, .is = 16 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_mmx, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_mmx, .to_mmx, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_w, .addus, .dst0q, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 16 } },
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 16 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .addus, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 16 } },
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 16 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_w, .addus, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_unsigned_int = .{ .of = .yword, .is = 16 } },
                        .{ .scalar_exact_unsigned_int = .{ .of = .yword, .is = 16 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .addus, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u16, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_w, .add, .dst0x, .src0x, .src1x, ._ },
                        .{ ._, .vp_w, .minu, .dst0x, .dst0x, .lea(.tmp0x), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u16, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_w, .add, .dst0x, .src1x, ._, ._ },
                        .{ ._, .p_w, .minu, .dst0x, .lea(.tmp0x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u16, .kind = .{ .umax_delta_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, .p_w, .add, .dst0x, .tmp2x, ._, ._ },
                        .{ ._, .p_w, .addus, .dst0x, .src1x, ._, ._ },
                        .{ ._, .p_w, .sub, .dst0x, .tmp2x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .yword, .is = .word } },
                        .{ .scalar_unsigned_int = .{ .of = .yword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u16, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .yword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_w, .add, .dst0y, .src0y, .src1y, ._ },
                        .{ ._, .vp_w, .minu, .dst0y, .dst0y, .lea(.tmp0y), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 32 } },
                        .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 32 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_d, .add, .dst0x, .src0x, .src1x, ._ },
                        .{ ._, .vp_d, .sra, .tmp2x, .src0x, .ui(31), ._ },
                        .{ ._, .vp_d, .cmpgt, .tmp3x, .src0x, .dst0x, ._ },
                        .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .lea(.tmp0x), ._ },
                        .{ ._, .vp_, .xor, .tmp3x, .tmp3x, .src1x, ._ },
                        .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp2x, .tmp3x },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 32 } },
                        .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 32 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i32, .kind = .{ .reg = .xmm0 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._dqa, .mov, .dst0x, .src0x, ._, ._ },
                        .{ ._, .p_d, .add, .dst0x, .src1x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .src0x, ._, ._ },
                        .{ ._, .p_d, .sra, .tmp2x, .ui(31), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp3x, .src0x, ._, ._ },
                        .{ ._, .p_d, .cmpgt, .tmp3x, .dst0x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, .p_, .xor, .tmp3x, .src1x, ._, ._ },
                        .{ ._, ._ps, .blendv, .dst0x, .tmp2x, .tmp3x, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_signed_int = .{ .of = .yword, .is = 32 } },
                        .{ .scalar_exact_signed_int = .{ .of = .yword, .is = 32 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i32, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_d, .add, .dst0y, .src0y, .src1y, ._ },
                        .{ ._, .vp_d, .sra, .tmp2y, .src0y, .ui(31), ._ },
                        .{ ._, .vp_d, .cmpgt, .tmp3y, .src0y, .dst0y, ._ },
                        .{ ._, .vp_, .xor, .tmp2y, .tmp2y, .lea(.tmp0y), ._ },
                        .{ ._, .vp_, .xor, .tmp3y, .tmp3y, .src1y, ._ },
                        .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp2y, .tmp3y },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_4_i32, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_d, .add, .dst0x, .src0x, .src1x, ._ },
                        .{ ._, .vp_d, .maxs, .dst0x, .dst0x, .lea(.tmp0x), ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                        .{ ._, .vp_d, .mins, .dst0x, .dst0x, .lea(.tmp0x), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_4_i32, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_d, .add, .dst0x, .src1x, ._, ._ },
                        .{ ._, .p_d, .maxs, .dst0x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                        .{ ._, .p_d, .mins, .dst0x, .lea(.tmp0x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .yword, .is = .dword } },
                        .{ .scalar_signed_int = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i32, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .yword } } },
                        .{ .type = .vector_8_i32, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_d, .add, .dst0y, .src0y, .src1y, ._ },
                        .{ ._, .vp_d, .maxs, .dst0y, .dst0y, .lea(.tmp0y), ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                        .{ ._, .vp_d, .mins, .dst0y, .dst0y, .lea(.tmp0y), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 32 } },
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 32 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .cmpeq, .dst0x, .dst0x, .dst0x, ._ },
                        .{ ._, .vp_, .xor, .dst0x, .src0x, .dst0x, ._ },
                        .{ ._, .vp_d, .minu, .dst0x, .dst0x, .src1x, ._ },
                        .{ ._, .vp_d, .add, .dst0x, .dst0x, .src0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 32 } },
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 32 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_d, .cmpeq, .dst0x, .dst0x, ._, ._ },
                        .{ ._, .p_, .xor, .dst0x, .src0x, ._, ._ },
                        .{ ._, .p_d, .minu, .dst0x, .src1x, ._, ._ },
                        .{ ._, .p_d, .add, .dst0x, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_unsigned_int = .{ .of = .yword, .is = 32 } },
                        .{ .scalar_exact_unsigned_int = .{ .of = .yword, .is = 32 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .cmpeq, .dst0y, .dst0y, .dst0y, ._ },
                        .{ ._, .vp_, .xor, .dst0y, .src0y, .dst0y, ._ },
                        .{ ._, .vp_d, .minu, .dst0y, .dst0y, .src1y, ._ },
                        .{ ._, .vp_d, .add, .dst0y, .dst0y, .src0y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u32, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_d, .add, .dst0x, .src0x, .src1x, ._ },
                        .{ ._, .vp_d, .minu, .dst0x, .dst0x, .lea(.tmp0x), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u32, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_d, .add, .dst0x, .src1x, ._, ._ },
                        .{ ._, .p_d, .minu, .dst0x, .lea(.tmp0x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .yword, .is = .dword } },
                        .{ .scalar_unsigned_int = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u32, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .yword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_d, .add, .dst0y, .src0y, .src1y, ._ },
                        .{ ._, .vp_d, .minu, .dst0y, .dst0y, .lea(.tmp0y), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 64 } },
                        .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_i64, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ },
                        .{ ._, .vp_q, .add, .dst0x, .src0x, .src1x, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp2x, .tmp2x, .src0x, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp3x, .src0x, .dst0x, ._ },
                        .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .lea(.tmp0x), ._ },
                        .{ ._, .vp_, .xor, .tmp3x, .tmp3x, .src1x, ._ },
                        .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .tmp2x, .tmp3x },
                    } },
                }, .{
                    .required_features = .{ .sse4_2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 64 } },
                        .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_i64, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, ._dqa, .mov, .dst0x, .src0x, ._, ._ },
                        .{ ._, .p_q, .add, .dst0x, .src1x, ._, ._ },
                        .{ ._, .p_q, .cmpgt, .tmp2x, .src0x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp3x, .src0x, ._, ._ },
                        .{ ._, .p_q, .cmpgt, .tmp3x, .dst0x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, .p_, .xor, .tmp3x, .src1x, ._, ._ },
                        .{ ._, ._pd, .blendv, .dst0x, .tmp2x, .tmp3x, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_signed_int = .{ .of = .yword, .is = 64 } },
                        .{ .scalar_exact_signed_int = .{ .of = .yword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i64, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp2y, .tmp2y, .tmp2y, ._ },
                        .{ ._, .vp_q, .add, .dst0y, .src0y, .src1y, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp2y, .tmp2y, .src0y, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp3y, .src0y, .dst0y, ._ },
                        .{ ._, .vp_, .xor, .tmp2y, .tmp2y, .lea(.tmp0y), ._ },
                        .{ ._, .vp_, .xor, .tmp3y, .tmp3y, .src1y, ._ },
                        .{ ._, .v_pd, .blendv, .dst0y, .dst0y, .tmp2y, .tmp3y },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_q, .broadcast, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, .vp_q, .add, .dst0x, .src0x, .src1x, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp3x, .tmp2x, .dst0x, ._ },
                        .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp2x, .tmp3x },
                        .{ ._, .vp_q, .cmpeq, .tmp3x, .tmp3x, .tmp3x, ._ },
                        .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp3x, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp3x, .tmp2x, .dst0x, ._ },
                        .{ ._, .vp_b, .blendv, .dst0x, .tmp2x, .dst0x, .tmp3x },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, .vp_q, .add, .dst0x, .src0x, .src1x, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp3x, .tmp2x, .dst0x, ._ },
                        .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp2x, .tmp3x },
                        .{ ._, .vp_q, .cmpeq, .tmp3x, .tmp3x, .tmp3x, ._ },
                        .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp3x, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp3x, .tmp2x, .dst0x, ._ },
                        .{ ._, .vp_b, .blendv, .dst0x, .tmp2x, .dst0x, .tmp3x },
                    } },
                }, .{
                    .required_features = .{ .sse4_2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, .p_q, .add, .dst0x, .src1x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, .p_q, .cmpgt, .tmp3x, .dst0x, ._, ._ },
                        .{ ._, .p_b, .blendv, .dst0x, .tmp2x, .tmp3x, ._ },
                        .{ ._, .p_q, .cmpeq, .tmp3x, .tmp3x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .tmp3x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp3x, .dst0x, ._, ._ },
                        .{ ._, .p_q, .cmpgt, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, .p_b, .blendv, .dst0x, .tmp2x, .tmp3x, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .yword, .is = .qword } },
                        .{ .scalar_signed_int = .{ .of = .yword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ },
                        .{ ._, .vp_q, .add, .dst0y, .src0y, .src1y, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp3y, .tmp2y, .dst0y, ._ },
                        .{ ._, .vp_b, .blendv, .dst0y, .dst0y, .tmp2y, .tmp3y },
                        .{ ._, .vp_q, .cmpeq, .tmp3y, .tmp3y, .tmp3y, ._ },
                        .{ ._, .vp_, .xor, .tmp2y, .tmp2y, .tmp3y, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp3y, .tmp2y, .dst0y, ._ },
                        .{ ._, .vp_b, .blendv, .dst0y, .tmp2y, .dst0y, .tmp3y },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_q, .broadcast, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp3x, .src0x, .tmp2x, ._ },
                        .{ ._, .vp_q, .add, .dst0x, .src0x, .src1x, ._ },
                        .{ ._, .vp_, .xor, .tmp2x, .dst0x, .tmp2x, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp3x, .tmp3x, .tmp2x, ._ },
                        .{ ._, .vp_, .@"or", .dst0x, .dst0x, .tmp3x, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp3x, .src0x, .tmp2x, ._ },
                        .{ ._, .vp_q, .add, .dst0x, .src0x, .src1x, ._ },
                        .{ ._, .vp_, .xor, .tmp2x, .dst0x, .tmp2x, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp3x, .tmp3x, .tmp2x, ._ },
                        .{ ._, .vp_, .@"or", .dst0x, .dst0x, .tmp3x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp3x, .src0x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, .p_q, .add, .dst0x, .src1x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .dst0x, ._, ._ },
                        .{ ._, .p_q, .cmpgt, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, .p_, .@"or", .dst0x, .tmp3x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_unsigned_int = .{ .of = .yword, .is = 64 } },
                        .{ .scalar_exact_unsigned_int = .{ .of = .yword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp3y, .src0y, .tmp2y, ._ },
                        .{ ._, .vp_q, .add, .dst0y, .src0y, .src1y, ._ },
                        .{ ._, .vp_, .xor, .tmp2y, .dst0y, .tmp2y, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp3y, .tmp3y, .tmp2y, ._ },
                        .{ ._, .vp_, .@"or", .dst0y, .dst0y, .tmp3y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 63 } },
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 63 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_u64, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ },
                        .{ ._, .vp_q, .add, .dst0x, .src0x, .src1x, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp2x, .tmp2x, .dst0x, ._ },
                        .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .lea(.tmp0x), .tmp2x },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 63 } },
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 63 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_u64, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ },
                        .{ ._, .vp_q, .add, .dst0x, .src0x, .src1x, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp2x, .tmp2x, .dst0x, ._ },
                        .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .lea(.tmp0x), .tmp2x },
                    } },
                }, .{
                    .required_features = .{ .sse4_2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 63 } },
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 63 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_u64, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_2_u64, .kind = .{ .reg = .xmm0 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, .p_q, .add, .dst0x, .src1x, ._, ._ },
                        .{ ._, .p_q, .cmpgt, .tmp2x, .dst0x, ._, ._ },
                        .{ ._, .p_b, .blendv, .dst0x, .lea(.tmp0x), .tmp2x, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_unsigned_int = .{ .of = .yword, .is = 63 } },
                        .{ .scalar_exact_unsigned_int = .{ .of = .yword, .is = 63 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u64, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .yword } } },
                        .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp2y, .tmp2y, .tmp2y, ._ },
                        .{ ._, .vp_q, .add, .dst0y, .src0y, .src1y, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp2y, .tmp2y, .dst0y, ._ },
                        .{ ._, .vp_b, .blendv, .dst0y, .dst0y, .lea(.tmp0y), .tmp2y },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_q, .broadcast, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, .vp_q, .add, .dst0x, .src0x, .src1x, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp3x, .dst0x, .tmp2x, ._ },
                        .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp2x, .tmp3x },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, .vp_q, .add, .dst0x, .src0x, .src1x, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp3x, .dst0x, .tmp2x, ._ },
                        .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp2x, .tmp3x },
                    } },
                }, .{
                    .required_features = .{ .sse4_2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .reg = .xmm0 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, .p_q, .add, .dst0x, .src1x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp3x, .dst0x, ._, ._ },
                        .{ ._, .p_q, .cmpgt, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, .p_b, .blendv, .dst0x, .tmp2x, .tmp3x, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .yword, .is = .qword } },
                        .{ .scalar_unsigned_int = .{ .of = .yword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ },
                        .{ ._, .vp_q, .add, .dst0y, .src0y, .src1y, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp3y, .dst0y, .tmp2y, ._ },
                        .{ ._, .vp_b, .blendv, .dst0y, .dst0y, .tmp2y, .tmp3y },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_int = .{ .of = .yword, .is = 1 } },
                        .{ .multiple_scalar_exact_int = .{ .of = .yword, .is = 1 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_, .@"or", .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_int = .{ .of = .xword, .is = 1 } },
                        .{ .multiple_scalar_exact_int = .{ .of = .xword, .is = 1 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_, .@"or", .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_int = .{ .of = .xword, .is = 1 } },
                        .{ .multiple_scalar_exact_int = .{ .of = .xword, .is = 1 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_, .@"or", .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_int = .{ .of = .xword, .is = 1 } },
                        .{ .multiple_scalar_exact_int = .{ .of = .xword, .is = 1 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._ps, .@"or", .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .mmx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_int = .{ .of = .qword, .is = 1 } },
                        .{ .multiple_scalar_exact_int = .{ .of = .qword, .is = 1 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u8, .kind = .{ .rc = .mmx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._q, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_, .@"or", .tmp1q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .yword, .is = 8 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .yword, .is = 8 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_b, .adds, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 8 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 8 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_b, .adds, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 8 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 8 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_b, .adds, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .mmx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 8 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 8 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i8, .kind = .{ .rc = .mmx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._q, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_b, .adds, .tmp1q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 8 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 8 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2b, .ui(7), ._, ._ },
                        .{ ._, ._, .xor, .tmp2b, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .add, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 8 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 8 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2b, .ui(7), ._, ._ },
                        .{ ._, ._, .xor, .tmp2b, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .add, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 8 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 8 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._no, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1b, .ui(7), ._, ._ },
                        .{ ._, ._, .xor, .tmp1b, .sa(.src0, .add_smin), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 8 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 8 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._no, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1b, .ui(7), ._, ._ },
                        .{ ._, ._, .xor, .tmp1b, .sa(.src0, .add_smin), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_b, .cmpeq, .tmp2y, .tmp2y, .tmp2y, ._ },
                        .{ ._, .vp_b, .broadcast, .tmp3y, .lea(.tmp0b), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp2y, .tmp3y, .tmp2y, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp4y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_b, .add, .tmp4y, .tmp4y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .vp_b, .maxs, .tmp4y, .tmp4y, .tmp3y, ._ },
                        .{ ._, .vp_b, .mins, .tmp4y, .tmp4y, .tmp2y, ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp4y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_i8, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_b, .cmpeq, .tmp2x, .tmp2x, .tmp2x, ._ },
                        .{ ._, .v_dqa, .mov, .tmp3x, .lea(.tmp0x), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp2x, .tmp3x, .tmp2x, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_b, .add, .tmp4x, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .vp_b, .maxs, .tmp4x, .tmp4x, .tmp3x, ._ },
                        .{ ._, .vp_b, .mins, .tmp4x, .tmp4x, .tmp2x, ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_i8, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_b, .cmpeq, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp3x, .lea(.tmp0x), ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .tmp3x, ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_b, .add, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_b, .maxs, .tmp4x, .tmp3x, ._, ._ },
                        .{ ._, .p_b, .mins, .tmp4x, .tmp2x, ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_i8, .kind = .{ .slimit_delta_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_b, .sub, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, .p_b, .adds, .tmp3x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_b, .add, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, .p_b, .adds, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, .p_b, .sub, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2b, .ui(7), ._, ._ },
                        .{ ._, ._, .add, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp2b, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .sia(-1 << 7, .src0, .sub_smin), ._, ._ },
                        .{ ._, ._po, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2b, .ui(7), ._, ._ },
                        .{ ._, ._, .add, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp2b, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .sia(-1 << 7, .src0, .sub_smin), ._, ._ },
                        .{ ._, ._po, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .sia(-1 << 7, .src0, .sub_smin), ._, ._ },
                        .{ ._, ._pe, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1b, .ui(7), ._, ._ },
                        .{ ._, ._, .xor, .tmp1b, .sa(.src0, .add_smax), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .sia(-1 << 7, .src0, .sub_smin), ._, ._ },
                        .{ ._, ._pe, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1b, .ui(7), ._, ._ },
                        .{ ._, ._, .xor, .tmp1b, .sa(.src0, .add_smax), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .yword, .is = 8 } },
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .yword, .is = 8 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_b, .addus, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 8 } },
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 8 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_b, .addus, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 8 } },
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 8 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_b, .addus, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .mmx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .qword, .is = 8 } },
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .qword, .is = 8 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u8, .kind = .{ .rc = .mmx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._q, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_b, .addus, .tmp1q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .byte, .is = 8 } },
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .byte, .is = 8 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sbb, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp1b, .tmp2b, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .byte, .is = 8 } },
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .byte, .is = 8 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sbb, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp1b, .tmp2b, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_b, .broadcast, .tmp2y, .lea(.tmp0b), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_b, .add, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .vp_b, .minu, .tmp3y, .tmp3y, .tmp2y, ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp3y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_b, .add, .tmp3x, .tmp3x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .vp_b, .minu, .tmp3x, .tmp3x, .tmp2x, ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_b, .add, .tmp3x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_b, .minu, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, .mmx, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u8, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .qword } } },
                        .{ .type = .vector_8_u8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._q, .mov, .tmp2q, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._q, .mov, .tmp3q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_b, .add, .tmp3q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_b, .minu, .tmp3q, .tmp2q, ._, ._ },
                        .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .ua(.src0, .add_umax), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .add, .tmp2b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp2b, .tmp1b, ._, ._ },
                        .{ ._, ._a, .cmov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .ua(.src0, .add_umax), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .add, .tmp2b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp2b, .tmp1b, ._, ._ },
                        .{ ._, ._a, .cmov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1b, .ua(.src0, .add_umax), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1b, .ua(.src0, .add_umax), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .yword, .is = 16 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .yword, .is = 16 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .adds, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 16 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 16 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .adds, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 16 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 16 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_w, .adds, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .fast_imm16, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 16 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 16 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .tmp2w, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .add, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 16 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 16 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .add, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 16 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 16 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._no, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .tmp1w, .sa(.src0, .add_smax), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 16 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 16 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._no, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .sa(.src0, .add_smax), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } },
                        .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_w, .cmpeq, .tmp2y, .tmp2y, .tmp2y, ._ },
                        .{ ._, .vp_w, .broadcast, .tmp3y, .lea(.tmp0w), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp2y, .tmp3y, .tmp2y, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp4y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .add, .tmp4y, .tmp4y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .vp_w, .maxs, .tmp4y, .tmp4y, .tmp3y, ._ },
                        .{ ._, .vp_w, .mins, .tmp4y, .tmp4y, .tmp2y, ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp4y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } },
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i16, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_w, .cmpeq, .tmp2x, .tmp2x, .tmp2x, ._ },
                        .{ ._, .v_dqa, .mov, .tmp3x, .lea(.tmp0x), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp2x, .tmp3x, .tmp2x, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .add, .tmp4x, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .vp_w, .maxs, .tmp4x, .tmp4x, .tmp3x, ._ },
                        .{ ._, .vp_w, .mins, .tmp4x, .tmp4x, .tmp2x, ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } },
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i16, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_w, .cmpeq, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp3x, .lea(.tmp0x), ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .tmp3x, ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_w, .add, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_w, .maxs, .tmp4x, .tmp3x, ._, ._ },
                        .{ ._, .p_w, .mins, .tmp4x, .tmp2x, ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .fast_imm16, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 15 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 15 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ },
                        .{ ._, ._, .add, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp2w, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp3w, .tmp3w, ._, ._ },
                        .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 15 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 15 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ },
                        .{ ._, ._, .add, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp3w, .tmp3w, ._, ._ },
                        .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 15 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 15 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp2w, .tmp2w, ._, ._ },
                        .{ ._, ._no, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .tmp1w, .sa(.src0, .add_smax), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 15 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 15 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp2w, .tmp2w, ._, ._ },
                        .{ ._, ._no, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .sa(.src0, .add_smax), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi2, .cmov, .fast_imm16, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ },
                        .{ ._, ._, .add, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp2w, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._rx, .ro, .tmp3d, .tmp1d, .uia(1, .src0, .add_bit_size_rem_64), ._ },
                        .{ ._, ._, .add, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi2, .cmov, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ },
                        .{ ._, ._, .add, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._rx, .ro, .tmp3d, .tmp1d, .uia(1, .src0, .add_bit_size_rem_64), ._ },
                        .{ ._, ._, .add, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .fast_imm16, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ },
                        .{ ._, ._, .add, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp2w, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp3d, .uia(31, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .add, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ },
                        .{ ._, ._, .add, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp3d, .uia(31, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .add, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp2d, .uia(31, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .add, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._no, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .tmp1w, .sa(.src0, .add_smax), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp2d, .uia(31, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .add, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._no, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .sa(.src0, .add_smax), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .mmx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .qword, .is = 16 } },
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .qword, .is = 16 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i16, .kind = .{ .rc = .mmx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._q, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_w, .addus, .tmp1q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .yword, .is = 16 } },
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .yword, .is = 16 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .addus, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 16 } },
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 16 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .addus, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 16 } },
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 16 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_w, .addus, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .mmx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .qword, .is = 16 } },
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .qword, .is = 16 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u16, .kind = .{ .rc = .mmx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._q, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_w, .addus, .tmp1q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .word, .is = 16 } },
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .word, .is = 16 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sbb, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .word } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_w, .broadcast, .tmp2y, .lea(.tmp0w), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .add, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .vp_w, .minu, .tmp3y, .tmp3y, .tmp2y, ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp3y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u16, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .add, .tmp3x, .tmp3x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .vp_w, .minu, .tmp3x, .tmp3x, .tmp2x, ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u16, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_w, .add, .tmp3x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_w, .minu, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u16, .kind = .{ .umax_delta_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_w, .add, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, .p_w, .addus, .tmp3x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_w, .sub, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .ua(.src0, .add_umax), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .add, .tmp2w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._a, .cmov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1w, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .ua(.src0, .add_umax), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1d, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .ua(.src0, .add_umax), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .yword, .is = 32 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .yword, .is = 32 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_d, .broadcast, .tmp2y, .lea(.tmp0d), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp4y, .memia(.src1y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_d, .add, .tmp5y, .tmp3y, .tmp4y, ._ },
                        .{ ._, .vp_d, .sra, .tmp6y, .tmp3y, .ui(31), ._ },
                        .{ ._, .vp_d, .cmpgt, .tmp3y, .tmp3y, .tmp5y, ._ },
                        .{ ._, .vp_, .xor, .tmp6y, .tmp6y, .tmp2y, ._ },
                        .{ ._, .vp_, .xor, .tmp3y, .tmp3y, .tmp4y, ._ },
                        .{ ._, .v_ps, .blendv, .tmp3y, .tmp5y, .tmp6y, .tmp3y },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp3y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 32 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 32 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_ss, .broadcast, .tmp2x, .lea(.tmp0d), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_d, .add, .tmp5x, .tmp3x, .tmp4x, ._ },
                        .{ ._, .vp_d, .sra, .tmp6x, .tmp3x, .ui(31), ._ },
                        .{ ._, .vp_d, .cmpgt, .tmp3x, .tmp3x, .tmp5x, ._ },
                        .{ ._, .vp_, .xor, .tmp6x, .tmp6x, .tmp2x, ._ },
                        .{ ._, .vp_, .xor, .tmp3x, .tmp3x, .tmp4x, ._ },
                        .{ ._, .v_ps, .blendv, .tmp3x, .tmp5x, .tmp6x, .tmp3x },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 32 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 32 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i32, .kind = .{ .reg = .xmm0 } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp5x, .tmp3x, ._, ._ },
                        .{ ._, .p_d, .add, .tmp5x, .tmp4x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp6x, .tmp3x, ._, ._ },
                        .{ ._, .p_d, .sra, .tmp6x, .ui(31), ._, ._ },
                        .{ ._, .p_d, .cmpgt, .tmp3x, .tmp5x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp6x, .tmp2x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp3x, .tmp4x, ._, ._ },
                        .{ ._, ._ps, .blendv, .tmp5x, .tmp6x, .tmp3x, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp5x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .dword, .is = 32 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .dword, .is = 32 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .add, .tmp1d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .dword, .is = 32 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .dword, .is = 32 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._no, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .sa(.src0, .add_smin), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_d, .cmpeq, .tmp2y, .tmp2y, .tmp2y, ._ },
                        .{ ._, .vp_d, .broadcast, .tmp3y, .lea(.tmp0d), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp2y, .tmp3y, .tmp2y, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp4y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_d, .add, .tmp4y, .tmp4y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .vp_d, .maxs, .tmp4y, .tmp4y, .tmp3y, ._ },
                        .{ ._, .vp_d, .mins, .tmp4y, .tmp4y, .tmp2y, ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp4y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_d, .cmpeq, .tmp2x, .tmp2x, .tmp2x, ._ },
                        .{ ._, .v_ss, .broadcast, .tmp3x, .lea(.tmp0d), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp2x, .tmp3x, .tmp2x, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_d, .add, .tmp4x, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .vp_d, .maxs, .tmp4x, .tmp4x, .tmp3x, ._ },
                        .{ ._, .vp_d, .mins, .tmp4x, .tmp4x, .tmp2x, ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_d, .cmpeq, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp3x, .lea(.tmp0x), ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .tmp3x, ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_d, .add, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_d, .maxs, .tmp4x, .tmp3x, ._, ._ },
                        .{ ._, .p_d, .mins, .tmp4x, .tmp2x, ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .dword, .is = 31 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .dword, .is = 31 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ },
                        .{ ._, ._, .add, .tmp1d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .dword, .is = 31 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .dword, .is = 31 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._no, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .sa(.src0, .add_smax), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi2, .cmov, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ },
                        .{ ._, ._, .add, .tmp1d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._rx, .ro, .tmp3d, .tmp1d, .uia(1, .src0, .add_bit_size_rem_64), ._ },
                        .{ ._, ._, .add, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ },
                        .{ ._, ._, .add, .tmp1d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp3d, .uia(31, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .add, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp2d, .uia(31, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .add, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._no, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .sa(.src0, .add_smax), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .yword, .is = 32 } },
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .yword, .is = 32 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, .vp_d, .cmpeq, .tmp1y, .tmp1y, .tmp1y, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp2y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp3y, .tmp2y, .tmp1y, ._ },
                        .{ ._, .vp_d, .minu, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .vp_d, .add, .tmp2y, .tmp3y, .tmp2y, ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp2y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 32 } },
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 32 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, .vp_d, .cmpeq, .tmp1x, .tmp1x, .tmp1x, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp2x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp3x, .tmp2x, .tmp1x, ._ },
                        .{ ._, .vp_d, .minu, .tmp3x, .tmp3x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .vp_d, .add, .tmp2x, .tmp3x, .tmp2x, ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 32 } },
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 32 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_d, .cmpeq, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_, .xor, .tmp1x, .tmp2x, ._, ._ },
                        .{ ._, .p_d, .minu, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_d, .add, .tmp1x, .tmp2x, ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .dword, .is = 32 } },
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .dword, .is = 32 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sbb, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_d, .broadcast, .tmp2y, .lea(.tmp0d), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_d, .add, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .vp_d, .minu, .tmp3y, .tmp3y, .tmp2y, ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp3y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_ss, .broadcast, .tmp2x, .lea(.tmp0d), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_d, .add, .tmp3x, .tmp3x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .vp_d, .minu, .tmp3x, .tmp3x, .tmp2x, ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u32, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_d, .add, .tmp3x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_d, .minu, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .ua(.src0, .add_umax), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .add, .tmp2d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._a, .cmov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1d, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .ua(.src0, .add_umax), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .yword, .is = 64 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .yword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp4y, .memia(.src1y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp5y, .tmp5y, .tmp5y, ._ },
                        .{ ._, .vp_q, .add, .tmp6y, .tmp3y, .tmp4y, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp5y, .tmp5y, .tmp3y, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp3y, .tmp3y, .tmp6y, ._ },
                        .{ ._, .vp_, .xor, .tmp5y, .tmp5y, .tmp2y, ._ },
                        .{ ._, .vp_, .xor, .tmp3y, .tmp3y, .tmp4y, ._ },
                        .{ ._, .v_pd, .blendv, .tmp5y, .tmp6y, .tmp5y, .tmp3y },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp5y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 64 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp5x, .tmp5x, .tmp5x, ._ },
                        .{ ._, .vp_q, .add, .tmp6x, .tmp3x, .tmp4x, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp5x, .tmp5x, .tmp3x, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp3x, .tmp3x, .tmp6x, ._ },
                        .{ ._, .vp_, .xor, .tmp5x, .tmp5x, .tmp2x, ._ },
                        .{ ._, .vp_, .xor, .tmp3x, .tmp3x, .tmp4x, ._ },
                        .{ ._, .v_pd, .blendv, .tmp5x, .tmp6x, .tmp5x, .tmp3x },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp5x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 64 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_, .xor, .tmp5x, .tmp5x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp6x, .tmp3x, ._, ._ },
                        .{ ._, .p_q, .add, .tmp6x, .tmp4x, ._, ._ },
                        .{ ._, .p_q, .cmpgt, .tmp5x, .tmp3x, ._, ._ },
                        .{ ._, .p_q, .cmpgt, .tmp3x, .tmp6x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp5x, .tmp2x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp3x, .tmp4x, ._, ._ },
                        .{ ._, ._pd, .blendv, .tmp6x, .tmp5x, .tmp3x, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp6x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 64 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp2q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ ._, ._, .xor, .tmp3q, .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._o, .cmov, .tmp2q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 64 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smin), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .add, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._no, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ },
                        .{ ._, ._, .xor, .tmp2q, .tmp1q, ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_q, .cmpeq, .tmp2y, .tmp2y, .tmp2y, ._ },
                        .{ ._, .vp_q, .broadcast, .tmp3y, .lea(.tmp0q), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp2y, .tmp3y, .tmp2y, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp4y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_q, .add, .tmp4y, .tmp4y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp5y, .tmp3y, .tmp4y, ._ },
                        .{ ._, .vp_b, .blendv, .tmp4y, .tmp4y, .tmp3y, .tmp5y },
                        .{ ._, .vp_q, .cmpgt, .tmp5y, .tmp4y, .tmp2y, ._ },
                        .{ ._, .vp_b, .blendv, .tmp4y, .tmp4y, .tmp2y, .tmp5y },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp4y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_q, .cmpeq, .tmp2x, .tmp2x, .tmp2x, ._ },
                        .{ ._, .v_, .movddup, .tmp3x, .lea(.tmp0q), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp2x, .tmp3x, .tmp2x, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_q, .add, .tmp4x, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp5x, .tmp3x, .tmp4x, ._ },
                        .{ ._, .vp_b, .blendv, .tmp4x, .tmp4x, .tmp3x, .tmp5x },
                        .{ ._, .vp_q, .cmpgt, .tmp5x, .tmp4x, .tmp2x, ._ },
                        .{ ._, .vp_b, .blendv, .tmp4x, .tmp4x, .tmp2x, .tmp5x },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_q, .cmpeq, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, ._, .movddup, .tmp3x, .lea(.tmp0q), ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .tmp3x, ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_q, .add, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp5x, .tmp3x, ._, ._ },
                        .{ ._, .p_q, .cmpgt, .tmp5x, .tmp4x, ._, ._ },
                        .{ ._, .p_b, .blendv, .tmp4x, .tmp3x, .tmp5x, ._ },
                        .{ ._, ._dqa, .mov, .tmp5x, .tmp4x, ._, ._ },
                        .{ ._, .p_q, .cmpgt, .tmp5x, .tmp2x, ._, ._ },
                        .{ ._, .p_b, .blendv, .tmp4x, .tmp2x, .tmp5x, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 63 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 63 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp2q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ ._, ._, .add, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp3q, .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._, .add, .tmp4q, .tmp4q, ._, ._ },
                        .{ ._, ._o, .cmov, .tmp2q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 63 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 63 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .add, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp2q, ._, ._ },
                        .{ ._, ._, .add, .tmp3q, .tmp3q, ._, ._ },
                        .{ ._, ._no, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ },
                        .{ ._, ._, .xor, .tmp2q, .tmp1q, ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, .cmov, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp2q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ ._, ._, .add, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp3q, .tmp1q, ._, ._ },
                        .{ ._, ._rx, .ro, .tmp4q, .tmp2q, .sia(-31, .src0, .add_bit_size_rem_64), ._ },
                        .{ ._, ._, .add, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._o, .cmov, .tmp2q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp2q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ ._, ._, .add, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp3q, .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp4q, .sia(-31, .src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .add, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._o, .cmov, .tmp2q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .add, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp2q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .sia(-31, .src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .add, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._no, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ },
                        .{ ._, ._, .xor, .tmp2q, .tmp1q, ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .yword, .is = 64 } },
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .yword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp4y, .tmp3y, .tmp2y, ._ },
                        .{ ._, .vp_q, .add, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .vp_, .xor, .tmp5y, .tmp3y, .tmp2y, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp4y, .tmp4y, .tmp5y, ._ },
                        .{ ._, .vp_, .@"or", .tmp3y, .tmp3y, .tmp4y, ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp3y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp4x, .tmp3x, .tmp2x, ._ },
                        .{ ._, .vp_q, .add, .tmp3x, .tmp3x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .vp_, .xor, .tmp5x, .tmp3x, .tmp2x, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp4x, .tmp4x, .tmp5x, ._ },
                        .{ ._, .vp_, .@"or", .tmp3x, .tmp3x, .tmp4x, ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp4x, .tmp2x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp4x, .tmp3x, ._, ._ },
                        .{ ._, .p_q, .add, .tmp3x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp5x, .tmp2x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp5x, .tmp3x, ._, ._ },
                        .{ ._, .p_q, .cmpgt, .tmp4x, .tmp5x, ._, ._ },
                        .{ ._, .p_, .@"or", .tmp3x, .tmp4x, ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .qword, .is = 64 } },
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .qword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sbb, .tmp2q, .tmp2q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp1q, .tmp2q, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .yword, .is = 63 } },
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .yword, .is = 63 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp4y, .tmp4y, .tmp4y, ._ },
                        .{ ._, .vp_q, .add, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp4y, .tmp4y, .tmp3y, ._ },
                        .{ ._, .vp_b, .blendv, .tmp3y, .tmp3y, .tmp2y, .tmp4y },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp3y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 63 } },
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 63 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp4x, .tmp4x, .tmp4x, ._ },
                        .{ ._, .vp_q, .add, .tmp3x, .tmp3x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp4x, .tmp4x, .tmp3x, ._ },
                        .{ ._, .vp_b, .blendv, .tmp3x, .tmp3x, .tmp2x, .tmp4x },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 63 } },
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 63 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .reg = .xmm0 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_, .xor, .tmp4x, .tmp4x, ._, ._ },
                        .{ ._, .p_q, .add, .tmp3x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_q, .cmpgt, .tmp4x, .tmp3x, ._, ._ },
                        .{ ._, .p_b, .blendv, .tmp3x, .tmp2x, .tmp4x, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .qword } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_q, .add, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp4y, .tmp3y, .tmp2y, ._ },
                        .{ ._, .vp_b, .blendv, .tmp3y, .tmp3y, .tmp2y, .tmp4y },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp3y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_q, .add, .tmp3x, .tmp3x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp4x, .tmp3x, .tmp2x, ._ },
                        .{ ._, .vp_b, .blendv, .tmp3x, .tmp3x, .tmp2x, .tmp4x },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .reg = .xmm0 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_q, .add, .tmp3x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp4x, .tmp3x, ._, ._ },
                        .{ ._, .p_q, .cmpgt, .tmp4x, .tmp2x, ._, ._ },
                        .{ ._, .p_b, .blendv, .tmp3x, .tmp2x, .tmp4x, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .add, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp2q, .tmp1q, ._, ._ },
                        .{ ._, ._a, .cmov, .tmp2q, .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .add, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp2q, .tmp1q, ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp1q, ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_remainder_signed_int = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_exact_remainder_signed_int = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .reg = .rcx } },
                        .{ .type = .i64, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memiad(.src0, .tmp0, .add_unaligned_size_add_elem_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memiad(.src1, .tmp0, .add_unaligned_size_add_elem_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .memiad(.dst0, .tmp0, .add_unaligned_size_add_elem_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp4p, .sia(1, .src0, .sub_elem_size_div_8), ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp5q, .leasi(.tmp1q, .@"8", .tmp4), ._, ._ },
                        .{ ._, ._, .adc, .tmp5q, .leasi(.tmp2q, .@"8", .tmp4), ._, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp3q, .@"8", .tmp4), .tmp5q, ._, ._ },
                        .{ ._, ._c, .in, .tmp4p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .lea(.tmp1q), ._, ._ },
                        .{ ._, ._, .adc, .tmp5q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._no, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaad(.tmp3, .sub_src0_elem_size, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp4d, .sia(-1, .src0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, ._r, .sa, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp4q, ._, ._ },
                        .{ .@"1:", ._, .mov, .lea(.tmp3q), .tmp5q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_exact_remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .si(-1), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp2p, .memia(.src0, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .memia(.src1, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp4p, .memia(.dst0, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp5p, .sa(.src0, .sub_elem_size_div_8), ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .adc, .tmp6q, .leasi(.tmp3q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp4q, .@"8", .tmp5), .tmp6q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._nc, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp5p, .leaa(.tmp4, .sub_src0_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .sa(.src0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ .@"1:", ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_remainder_signed_int = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_exact_remainder_signed_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .reg = .rcx } },
                        .{ .type = .i64, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memiad(.src0, .tmp0, .add_unaligned_size_add_elem_size, -16), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memiad(.src1, .tmp0, .add_unaligned_size_add_elem_size, -16), ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .memiad(.dst0, .tmp0, .add_unaligned_size_add_elem_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp4p, .sia(2, .src0, .sub_elem_size_div_8), ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp5q, .leasi(.tmp1q, .@"8", .tmp4), ._, ._ },
                        .{ ._, ._, .adc, .tmp5q, .leasi(.tmp2q, .@"8", .tmp4), ._, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp3q, .@"8", .tmp4), .tmp5q, ._, ._ },
                        .{ ._, ._c, .in, .tmp4p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .lea(.tmp1q), ._, ._ },
                        .{ ._, ._, .adc, .tmp5q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._no, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaad(.tmp3, .sub_src0_elem_size, 16), ._, ._ },
                        .{ ._, ._, .mov, .tmp4d, .sia(-2, .src0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, ._r, .sa, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp4q, ._, ._ },
                        .{ .@"1:", ._, .mov, .lea(.tmp3q), .tmp5q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .lead(.tmp3q, 8), .tmp5q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .si(-1), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp2p, .memiad(.src0, .tmp0, .add_unaligned_size_add_elem_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .memiad(.src1, .tmp0, .add_unaligned_size_add_elem_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp4p, .memiad(.dst0, .tmp0, .add_unaligned_size_add_elem_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5p, .sia(1, .src0, .sub_elem_size_div_8), ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .adc, .tmp6q, .leasi(.tmp3q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp4q, .@"8", .tmp5), .tmp6q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._nc, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp5p, .leaad(.tmp4, .sub_src0_elem_size, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .sia(-1, .src0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .lea(.tmp4q), .si(0), ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .reg = .rcx } },
                        .{ .type = .i64, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memiad(.src0, .tmp0, .add_unaligned_size_add_elem_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memiad(.src1, .tmp0, .add_unaligned_size_add_elem_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .memiad(.dst0, .tmp0, .add_unaligned_size_add_elem_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp4p, .sia(1, .src0, .sub_elem_size_div_8), ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp5q, .leasi(.tmp1q, .@"8", .tmp4), ._, ._ },
                        .{ ._, ._, .adc, .tmp5q, .leasi(.tmp2q, .@"8", .tmp4), ._, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp3q, .@"8", .tmp4), .tmp5q, ._, ._ },
                        .{ ._, ._c, .in, .tmp4p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._l, .sa, .tmp5q, .uia(63, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .add, .tmp5q, .tmp5q, ._, ._ },
                        .{ ._, ._no, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaad(.tmp3, .sub_src0_elem_size, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp4d, .sia(-2, .src0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, ._r, .sa, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .lead(.tmp3q, -8), .tmp5q, ._, ._ },
                        .{ .@"1:", ._r, .sa, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .lea(.tmp3q), .tmp5q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .si(-1), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp3p, .memiad(.src0, .tmp0, .add_unaligned_size_add_elem_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp4p, .memiad(.src1, .tmp0, .add_unaligned_size_add_elem_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp5p, .memiad(.dst0, .tmp0, .add_unaligned_size_add_elem_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6p, .sia(1, .src0, .sub_elem_size_div_8), ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp7q, .leasi(.tmp3q, .@"8", .tmp6), ._, ._ },
                        .{ ._, ._, .adc, .tmp7q, .leasi(.tmp4q, .@"8", .tmp6), ._, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp5q, .@"8", .tmp6), .tmp7q, ._, ._ },
                        .{ ._, ._c, .in, .tmp6p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .cmp, .tmp7q, .tmp1q, ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .lead(.tmp5q, -8), .tmp1q, ._, ._ },
                        .{ ._, ._, .lea, .tmp6p, .leaad(.tmp5, .sub_src0_elem_size, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp7d, .sia(-2, .src0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .lea(.tmp5q), .si(0), ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .reg = .rcx } },
                        .{ .type = .i64, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memia(.src1, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .memia(.dst0, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp4p, .sa(.src0, .sub_elem_size_div_8), ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp5q, .leasi(.tmp1q, .@"8", .tmp4), ._, ._ },
                        .{ ._, ._, .adc, .tmp5q, .leasi(.tmp2q, .@"8", .tmp4), ._, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp3q, .@"8", .tmp4), .tmp5q, ._, ._ },
                        .{ ._, ._c, .in, .tmp4p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._l, .sa, .tmp5q, .uia(63, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .add, .tmp5q, .tmp5q, ._, ._ },
                        .{ ._, ._no, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp3, .sub_src0_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp4d, .sia(-1, .src0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, ._r, .sa, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .lead(.tmp3q, -8), .tmp5q, ._, ._ },
                        .{ .@"1:", ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .si(-1), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp3p, .memia(.src0, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp4p, .memia(.src1, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp5p, .memia(.dst0, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp6p, .sa(.src0, .sub_elem_size_div_8), ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp7q, .leasi(.tmp3q, .@"8", .tmp6), ._, ._ },
                        .{ ._, ._, .adc, .tmp7q, .leasi(.tmp4q, .@"8", .tmp6), ._, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp5q, .@"8", .tmp6), .tmp7q, ._, ._ },
                        .{ ._, ._c, .in, .tmp6p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .cmp, .tmp7q, .tmp1q, ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp6p, .leaa(.tmp5, .sub_src0_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp7d, .sia(-1, .src0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .lead(.tmp5q, -8), .tmp1q, ._, ._ },
                        .{ .@"1:", ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f} {f}", .{
                        @tagName(air_tag),
                        cg.typeOf(bin_op.lhs).fmt(pt),
                        ops[0].tracking(cg),
                        ops[1].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
            },
            .sub, .sub_optimized, .sub_wrap => |air_tag| {
                const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                var res: [1]Temp = undefined;
                cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{
                    .src_constraints = .{ .{ .int = .byte }, .{ .int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .imm8, .none } },
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                        .{ .src = .{ .mut_mem, .to_gpr, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0b, .src1b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .int = .word }, .{ .int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .imm16, .none } },
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .mut_mem, .to_gpr, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .int = .dword }, .{ .int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .imm32, .none } },
                        .{ .src = .{ .to_mut_gpr, .imm32, .none } },
                        .{ .src = .{ .mut_mem, .to_gpr, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0d, .src1d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .int = .qword }, .{ .int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .simm32, .none } },
                        .{ .src = .{ .to_mut_gpr, .simm32, .none } },
                        .{ .src = .{ .mut_mem, .to_gpr, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0q, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_int = .{ .of = .qword, .is = .qword } },
                        .{ .remainder_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memsia(.src1q, .@"8", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_size), .tmp1q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .remainder_int = .{ .of = .dword, .is = .dword } },
                        .{ .remainder_int = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_4), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1d, .memsia(.src1d, .@"4", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_size), .tmp1d, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_int = .{ .of = .xword, .is = .byte } },
                        .{ .scalar_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_b, .sub, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_int = .{ .of = .xword, .is = .byte } },
                        .{ .scalar_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_b, .sub, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_int = .{ .of = .yword, .is = .byte } },
                        .{ .scalar_int = .{ .of = .yword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_b, .sub, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .yword, .is = .byte } },
                        .{ .multiple_scalar_int = .{ .of = .yword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_b, .sub, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .byte } },
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_b, .sub, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .byte } },
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_b, .sub, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_int = .{ .of = .xword, .is = .word } },
                        .{ .scalar_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .sub, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_int = .{ .of = .xword, .is = .word } },
                        .{ .scalar_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_w, .sub, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_int = .{ .of = .yword, .is = .word } },
                        .{ .scalar_int = .{ .of = .yword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .sub, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .yword, .is = .word } },
                        .{ .multiple_scalar_int = .{ .of = .yword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .sub, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .word } },
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .sub, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .word } },
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_w, .sub, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_int = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_int = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .sub, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_int = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_d, .sub, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_int = .{ .of = .yword, .is = .dword } },
                        .{ .scalar_int = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .sub, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .yword, .is = .dword } },
                        .{ .multiple_scalar_int = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_d, .sub, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } },
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_d, .sub, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } },
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_d, .sub, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } },
                        .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_int = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_q, .sub, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_int = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_q, .sub, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_int = .{ .of = .yword, .is = .qword } },
                        .{ .scalar_int = .{ .of = .yword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_q, .sub, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .yword, .is = .qword } },
                        .{ .multiple_scalar_int = .{ .of = .yword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_q, .sub, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } },
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_q, .sub, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } },
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_q, .sub, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memia(.src1, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .memia(.dst0, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp4p, .sa(.src0, .sub_elem_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp5q, .leasi(.tmp1q, .@"8", .tmp4), ._, ._ },
                        .{ ._, ._, .sbb, .tmp5q, .leasi(.tmp2q, .@"8", .tmp4), ._, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp3q, .@"8", .tmp4), .tmp5q, ._, ._ },
                        .{ ._, ._c, .in, .tmp4p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .scalar_remainder_int = .{ .of = .dword, .is = .dword } },
                        .{ .scalar_remainder_int = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memia(.src1, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .memia(.dst0, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp4p, .sa(.src0, .sub_elem_size_div_4), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp5d, .leasi(.tmp1d, .@"4", .tmp4), ._, ._ },
                        .{ ._, ._, .sbb, .tmp5d, .leasi(.tmp2d, .@"4", .tmp4), ._, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp3d, .@"4", .tmp4), .tmp5d, ._, ._ },
                        .{ ._, ._c, .in, .tmp4p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
                        .{ ._, .v_ss, .sub, .dst0x, .dst0x, .tmp0d, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__subhf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .word } },
                        .{ .scalar_float = .{ .of = .qword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_4_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
                        .{ ._, .v_ps, .sub, .dst0x, .dst0x, .tmp0x, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .word } },
                        .{ .scalar_float = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ },
                        .{ ._, .v_ps, .sub, .dst0y, .dst0y, .tmp0y, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_ps, .sub, .tmp1y, .tmp1y, .tmp2y, ._ },
                        .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__subhf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ },
                        .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
                        .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0) },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__subhf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                        .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__subhf3" } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                        .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .tmp4d, .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__subhf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ss, .sub, .dst0x, .src0x, .src1d, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._ss, .sub, .dst0x, .src1d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .sub, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._ps, .sub, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .yword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .sub, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_ps, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_ps, .sub, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._ps, .sub, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_sd, .sub, .dst0x, .src0x, .src1q, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._sd, .sub, .dst0x, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f64, .kind = .{ .reg = .st6 } },
                        .{ .type = .f64, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0q, ._, ._, ._ },
                        .{ ._, .f_, .sub, .src1q, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_pd, .sub, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._pd, .sub, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .yword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .yword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_pd, .sub, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_pd, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_pd, .sub, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._pd, .sub, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .reg = .st6 } },
                        .{ .type = .f64, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, .f_, .sub, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, .f_p, .st, .memia(.dst0q, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
                        .{ ._, .f_p, .sub, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .msvc,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
                        .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp3d, .memd(.tmp2b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_00_11), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp2b, 1), .tmp3b, ._, ._ },
                        .{ ._, .f_p, .sub, ._, ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .f_, .subr, .tmp0t, .src1t, ._, ._ },
                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .msvc,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_00_11), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
                        .{ ._, .f_, .subr, .tmp0t, .src1t, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .to_x87, .none } },
                        .{ .src = .{ .to_x87, .to_x87, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .f_, .sub, .tmp0t, .src1t, ._, ._ },
                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .msvc,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .to_x87, .none } },
                        .{ .src = .{ .to_x87, .to_x87, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_00_11), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
                        .{ ._, .f_, .sub, .tmp0t, .src1t, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, .f_p, .sub, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .msvc,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .fn_cw, .st, .tmp0w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp1d, .memd(.tmp0b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp0b, 1), .ui(0b000_0_00_11), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp0b, 1), .tmp1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp1, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, .f_, .ld, .memia(.src1t, .tmp1, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, .f_p, .sub, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .memia(.dst0t, .tmp1, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__subtf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__subtf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__subtf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp2x, .memi(.src1x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__subtf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .memi(.src1x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__subtf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._ps, .mova, .tmp2x, .memi(.src1x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__subtf3" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memi(.src1, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp4x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__subtf3" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memi(.src1, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp4x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__subtf3" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memi(.src1, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp4x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f} {f}", .{
                        @tagName(air_tag),
                        cg.typeOf(bin_op.lhs).fmt(pt),
                        ops[0].tracking(cg),
                        ops[1].tracking(cg),
                    }),
                    else => |e| return e,
                };
                switch (air_tag) {
                    else => unreachable,
                    .sub, .sub_optimized => {},
                    .sub_wrap => res[0].wrapInt(cg) catch |err| switch (err) {
                        error.SelectFailed => return cg.fail("failed to select {s} wrap {f} {f}", .{
                            @tagName(air_tag),
                            cg.typeOf(bin_op.lhs).fmt(pt),
                            res[0].tracking(cg),
                        }),
                        else => |e| return e,
                    },
                }
                try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
            },
            .sub_safe => unreachable,
            .sub_sat => |air_tag| {
                const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                var res: [1]Temp = undefined;
                cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{
                    .src_constraints = .{ .{ .exact_int = 1 }, .{ .exact_int = 1 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .{ .imm = 0 }, .none } },
                        .{ .src = .{ .to_mut_gpr, .{ .imm = 0 }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{} },
                }, .{
                    .src_constraints = .{ .{ .exact_int = 1 }, .{ .exact_int = 1 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .imm = 0 }, .to_mut_gpr, .none } },
                        .{ .src = .{ .any, .imm8, .none } },
                    },
                    .dst_temps = .{ .{ .imm = 0 }, .unused },
                    .each = .{ .once = &.{} },
                }, .{
                    .required_features = .{ .bmi, null, null, null },
                    .src_constraints = .{ .{ .exact_int = 1 }, .{ .exact_int = 1 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .andn, .dst0d, .src1d, .src0d, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_int = 1 }, .{ .exact_int = 1 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .to_mut_gpr, .none } },
                        .{ .src = .{ .to_gpr, .to_mut_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src1 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .not, .src1b, ._, ._, ._ },
                        .{ ._, ._, .@"and", .dst0b, .src0b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 8 }, .{ .exact_signed_int = 8 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0b, .ui(7), ._, ._ },
                        .{ ._, ._, .xor, .tmp0b, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .sub, .dst0b, .src1b, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_signed_int = 8 }, .{ .exact_signed_int = 8 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0b, .src1b, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0b, .ui(7), ._, ._ },
                        .{ ._, ._, .xor, .dst0b, .sa(.src0, .add_smin), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0b, .ui(7), ._, ._ },
                        .{ ._, ._, .sub, .dst0b, .src1b, ._, ._ },
                        .{ ._, ._, .xor, .tmp0b, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .@"test", .dst0b, .sia(-1 << 7, .src0, .sub_smin), ._, ._ },
                        .{ ._, ._po, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0b, .src1b, ._, ._ },
                        .{ ._, ._, .@"test", .dst0b, .sia(-1 << 7, .src0, .sub_smin), ._, ._ },
                        .{ ._, ._pe, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0b, .ui(7), ._, ._ },
                        .{ ._, ._, .xor, .dst0b, .sa(.src0, .add_smax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .sub, .dst0b, .src1b, ._, ._ },
                        .{ ._, ._c, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u8, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0b, .src1b, ._, ._ },
                        .{ ._, ._, .cmc, ._, ._, ._, ._ },
                        .{ ._, ._, .sbb, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .@"and", .dst0b, .tmp0b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .fast_imm16, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 16 }, .{ .exact_signed_int = 16 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .tmp0w, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 16 }, .{ .exact_signed_int = 16 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 16 }, .{ .exact_signed_int = 16 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .dst0w, .sa(.src0, .add_smin), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_signed_int = 16 }, .{ .exact_signed_int = 16 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smin), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .fast_imm16, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 15 }, .{ .exact_signed_int = 15 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ },
                        .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._, .xor, .tmp0w, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ },
                        .{ ._, ._, .add, .tmp1w, .tmp1w, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .fast_imm16, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 15 }, .{ .exact_signed_int = 15 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ },
                        .{ ._, ._, .sub, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .xor, .tmp0w, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ },
                        .{ ._, ._, .add, .tmp1w, .tmp1w, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 15 }, .{ .exact_signed_int = 15 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ },
                        .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ },
                        .{ ._, ._, .add, .tmp1w, .tmp1w, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 15 }, .{ .exact_signed_int = 15 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ },
                        .{ ._, ._, .sub, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ },
                        .{ ._, ._, .add, .tmp1w, .tmp1w, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 15 }, .{ .exact_signed_int = 15 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._, .add, .tmp0w, .tmp0w, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .dst0w, .sa(.src0, .add_smax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 15 }, .{ .exact_signed_int = 15 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._, .add, .tmp0w, .tmp0w, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .dst0w, .sa(.src0, .add_smax), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_signed_int = 15 }, .{ .exact_signed_int = 15 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._, .add, .tmp0w, .tmp0w, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smax), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_signed_int = 15 }, .{ .exact_signed_int = 15 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._, .add, .tmp0w, .tmp0w, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi2, .cmov, .fast_imm16, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ },
                        .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._, .xor, .tmp0w, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._rx, .ro, .tmp1d, .dst0d, .uia(1, .src0, .add_bit_size), ._ },
                        .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi2, .cmov, .fast_imm16, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ },
                        .{ ._, ._, .sub, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .xor, .tmp0w, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._rx, .ro, .tmp1d, .dst0d, .uia(1, .src0, .add_bit_size), ._ },
                        .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi2, .cmov, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ },
                        .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._rx, .ro, .tmp1d, .dst0d, .uia(1, .src0, .add_bit_size), ._ },
                        .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi2, .cmov, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ },
                        .{ ._, ._, .sub, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._rx, .ro, .tmp1d, .dst0d, .uia(1, .src0, .add_bit_size), ._ },
                        .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .fast_imm16, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ },
                        .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._, .xor, .tmp0w, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp1d, .uia(31, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .fast_imm16, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ },
                        .{ ._, ._, .sub, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .xor, .tmp0w, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp1d, .uia(31, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ },
                        .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp1d, .uia(31, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ },
                        .{ ._, ._, .sub, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp1d, .uia(31, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0d, .uia(31, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .dst0w, .sa(.src0, .add_smax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0d, .uia(31, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .dst0w, .sa(.src0, .add_smax), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0d, .uia(31, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smax), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0d, .uia(31, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._c, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._, .cmc, ._, ._, ._, ._ },
                        .{ ._, ._, .sbb, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .@"and", .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 32 }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm32, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .sub, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_signed_int = 32 }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm32, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smin), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 31 }, .{ .exact_signed_int = 31 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm32, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0d, .ui(31), ._, ._ },
                        .{ ._, ._, .sub, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ },
                        .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_signed_int = 31 }, .{ .exact_signed_int = 31 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm32, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._, .add, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi2, .cmov, null, null },
                    .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm32, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0d, .ui(31), ._, ._ },
                        .{ ._, ._, .sub, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._rx, .ro, .tmp1d, .dst0d, .uia(1, .src0, .add_bit_size), ._ },
                        .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm32, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0d, .ui(31), ._, ._ },
                        .{ ._, ._, .sub, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp1d, .uia(31, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm32, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0d, .uia(31, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm32, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .sub, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._c, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm32, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .cmc, ._, ._, ._, ._ },
                        .{ ._, ._, .sbb, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .@"and", .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 64 }, .{ .exact_signed_int = 64 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .simm32, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .xor, .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._, .sub, .dst0q, .src1q, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0q, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 64 }, .{ .exact_signed_int = 64 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .simm32, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0q, .src1q, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .dst0q, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 63 }, .{ .exact_signed_int = 63 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .simm32, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .sub, .dst0q, .src1q, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .xor, .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .dst0q, ._, ._ },
                        .{ ._, ._, .add, .tmp1q, .tmp1q, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0q, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 63 }, .{ .exact_signed_int = 63 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .simm32, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0q, .src1q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ },
                        .{ ._, ._, .add, .tmp0q, .tmp0q, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .xor, .dst0q, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, .cmov, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .simm32, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .sub, .dst0q, .src1q, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .xor, .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._rx, .ro, .tmp1q, .dst0q, .sia(-31, .src0, .add_bit_size), ._ },
                        .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0q, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .simm32, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .sub, .dst0q, .src1q, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .xor, .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .dst0q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp1q, .sia(-31, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0q, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .simm32, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0q, .src1q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0q, .sia(-31, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .xor, .dst0q, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .simm32, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .sub, .dst0q, .src1q, ._, ._ },
                        .{ ._, ._c, .cmov, .dst0q, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .simm32, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0q, .src1q, ._, ._ },
                        .{ ._, ._, .cmc, ._, ._, ._, ._ },
                        .{ ._, ._, .sbb, .tmp0q, .tmp0q, ._, ._ },
                        .{ ._, ._, .@"and", .dst0q, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 128 } },
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 128 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .i64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp1q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp2q, ._, ._ },
                        .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 64 } },
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .i64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(2, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -16), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -16), .tmp1q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -16), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -16), ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp2q, ._, ._ },
                        .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -16), .tmp1q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } },
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .i64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp1q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._l, .sa, .tmp1q, .uia(63, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .add, .tmp1q, .tmp1q, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp2q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp1q, ._, ._ },
                        .{ .@"0:", ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } },
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .i64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memsia(.src1q, .@"8", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_size), .tmp1q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._l, .sa, .tmp1q, .uia(63, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .add, .tmp1q, .tmp1q, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp2q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } },
                        .{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2q, .memsia(.src0q, .@"8", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .sbb, .tmp2q, .memsia(.src1q, .@"8", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_size), .tmp2q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._nc, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .mmx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_int = .{ .of = .qword, .is = 1 } },
                        .{ .scalar_exact_int = .{ .of = .qword, .is = 1 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .to_mut_mmx, .none } },
                        .{ .src = .{ .to_mmx, .to_mut_mmx, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src1 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_, .andn, .dst0q, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_int = .{ .of = .xword, .is = 1 } },
                        .{ .scalar_exact_int = .{ .of = .xword, .is = 1 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .to_sse, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_, .andn, .dst0x, .src1x, .src0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_int = .{ .of = .xword, .is = 1 } },
                        .{ .scalar_exact_int = .{ .of = .xword, .is = 1 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .to_mut_sse, .none } },
                        .{ .src = .{ .to_sse, .to_mut_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src1 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_, .andn, .dst0x, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_int = .{ .of = .xword, .is = 1 } },
                        .{ .scalar_exact_int = .{ .of = .xword, .is = 1 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .to_mut_sse, .none } },
                        .{ .src = .{ .to_sse, .to_mut_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src1 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._ps, .andn, .dst0x, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_int = .{ .of = .yword, .is = 1 } },
                        .{ .scalar_exact_int = .{ .of = .yword, .is = 1 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .to_sse, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_, .andn, .dst0y, .src1y, .src0y, ._ },
                    } },
                }, .{
                    .required_features = .{ .mmx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_signed_int = .{ .of = .qword, .is = 8 } },
                        .{ .scalar_exact_signed_int = .{ .of = .qword, .is = 8 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_mmx, .mem, .none } },
                        .{ .src = .{ .to_mut_mmx, .to_mmx, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_b, .subs, .dst0q, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 8 } },
                        .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 8 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_b, .subs, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 8 } },
                        .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 8 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_b, .subs, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_signed_int = .{ .of = .yword, .is = 8 } },
                        .{ .scalar_exact_signed_int = .{ .of = .yword, .is = 8 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_b, .subs, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_i8, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_16_i8, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_b, .sub, .dst0x, .src0x, .src1x, ._ },
                        .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .lea(.tmp0x), ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                        .{ ._, .vp_b, .mins, .dst0x, .dst0x, .lea(.tmp0x), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_i8, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_16_i8, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_b, .sub, .dst0x, .src1x, ._, ._ },
                        .{ ._, .p_b, .maxs, .dst0x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                        .{ ._, .p_b, .mins, .dst0x, .lea(.tmp0x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_i8, .kind = .{ .slimit_delta_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, .p_b, .sub, .dst0x, .tmp2x, ._, ._ },
                        .{ ._, .p_b, .subs, .dst0x, .src1x, ._, ._ },
                        .{ ._, .p_b, .add, .dst0x, .tmp2x, ._, ._ },
                        .{ ._, .p_b, .adds, .dst0x, .tmp2x, ._, ._ },
                        .{ ._, .p_b, .sub, .dst0x, .tmp2x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .yword, .is = .byte } },
                        .{ .scalar_signed_int = .{ .of = .yword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_32_i8, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .yword } } },
                        .{ .type = .vector_32_i8, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_b, .sub, .dst0y, .src0y, .src1y, ._ },
                        .{ ._, .vp_b, .maxs, .dst0y, .dst0y, .lea(.tmp0y), ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                        .{ ._, .vp_b, .mins, .dst0y, .dst0y, .lea(.tmp0y), ._ },
                    } },
                }, .{
                    .required_features = .{ .mmx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } },
                        .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_mmx, .mem, .none } },
                        .{ .src = .{ .to_mut_mmx, .to_mmx, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_b, .subus, .dst0q, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_b, .subus, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_b, .subus, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .yword, .is = .byte } },
                        .{ .scalar_unsigned_int = .{ .of = .yword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_b, .subus, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .mmx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_signed_int = .{ .of = .qword, .is = 16 } },
                        .{ .scalar_exact_signed_int = .{ .of = .qword, .is = 16 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_mmx, .mem, .none } },
                        .{ .src = .{ .to_mut_mmx, .to_mmx, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_w, .subs, .dst0q, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 16 } },
                        .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 16 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .subs, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 16 } },
                        .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 16 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_w, .subs, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_signed_int = .{ .of = .yword, .is = 16 } },
                        .{ .scalar_exact_signed_int = .{ .of = .yword, .is = 16 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .subs, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, .mmx, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .word } },
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_mmx, .mem, .none } },
                        .{ .src = .{ .to_mut_mmx, .to_mmx, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i16, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .qword } } },
                        .{ .type = .vector_4_i16, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .qword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_w, .sub, .dst0q, .src1q, ._, ._ },
                        .{ ._, .p_w, .maxs, .dst0q, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                        .{ ._, .p_w, .mins, .dst0q, .lea(.tmp0q), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .word } },
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i16, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_8_i16, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_w, .sub, .dst0x, .src0x, .src1x, ._ },
                        .{ ._, .vp_w, .maxs, .dst0x, .dst0x, .lea(.tmp0x), ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                        .{ ._, .vp_w, .mins, .dst0x, .dst0x, .lea(.tmp0x), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .word } },
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i16, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_8_i16, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_w, .sub, .dst0x, .src1x, ._, ._ },
                        .{ ._, .p_w, .maxs, .dst0x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                        .{ ._, .p_w, .mins, .dst0x, .lea(.tmp0x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .yword, .is = .word } },
                        .{ .scalar_signed_int = .{ .of = .yword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_i16, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .yword } } },
                        .{ .type = .vector_16_i16, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_w, .sub, .dst0y, .src0y, .src1y, ._ },
                        .{ ._, .vp_w, .maxs, .dst0y, .dst0y, .lea(.tmp0y), ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                        .{ ._, .vp_w, .mins, .dst0y, .dst0y, .lea(.tmp0y), ._ },
                    } },
                }, .{
                    .required_features = .{ .mmx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .qword, .is = .word } },
                        .{ .scalar_unsigned_int = .{ .of = .qword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_mmx, .mem, .none } },
                        .{ .src = .{ .to_mut_mmx, .to_mmx, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_w, .subus, .dst0q, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .subus, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_w, .subus, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .yword, .is = .word } },
                        .{ .scalar_unsigned_int = .{ .of = .yword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .subus, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 32 } },
                        .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 32 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_d, .sub, .dst0x, .src0x, .src1x, ._ },
                        .{ ._, .vp_d, .sra, .tmp2x, .src0x, .ui(31), ._ },
                        .{ ._, .vp_d, .cmpgt, .tmp3x, .dst0x, .src0x, ._ },
                        .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .lea(.tmp0x), ._ },
                        .{ ._, .vp_, .xor, .tmp3x, .tmp3x, .src1x, ._ },
                        .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp2x, .tmp3x },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 32 } },
                        .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 32 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i32, .kind = .{ .reg = .xmm0 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._dqa, .mov, .dst0x, .src0x, ._, ._ },
                        .{ ._, .p_d, .sub, .dst0x, .src1x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .src0x, ._, ._ },
                        .{ ._, .p_d, .sra, .tmp2x, .ui(31), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp3x, .dst0x, ._, ._ },
                        .{ ._, .p_d, .cmpgt, .tmp3x, .src0x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, .p_, .xor, .tmp3x, .src1x, ._, ._ },
                        .{ ._, ._ps, .blendv, .dst0x, .tmp2x, .tmp3x, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_signed_int = .{ .of = .yword, .is = 32 } },
                        .{ .scalar_exact_signed_int = .{ .of = .yword, .is = 32 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i32, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_d, .sub, .dst0y, .src0y, .src1y, ._ },
                        .{ ._, .vp_d, .sra, .tmp2y, .src0y, .ui(31), ._ },
                        .{ ._, .vp_d, .cmpgt, .tmp3y, .dst0y, .src0y, ._ },
                        .{ ._, .vp_, .xor, .tmp2y, .tmp2y, .lea(.tmp0y), ._ },
                        .{ ._, .vp_, .xor, .tmp3y, .tmp3y, .src1y, ._ },
                        .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp2y, .tmp3y },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_4_i32, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_d, .sub, .dst0x, .src0x, .src1x, ._ },
                        .{ ._, .vp_d, .maxs, .dst0x, .dst0x, .lea(.tmp0x), ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                        .{ ._, .vp_d, .mins, .dst0x, .dst0x, .lea(.tmp0x), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_4_i32, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_d, .sub, .dst0x, .src1x, ._, ._ },
                        .{ ._, .p_d, .maxs, .dst0x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                        .{ ._, .p_d, .mins, .dst0x, .lea(.tmp0x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .yword, .is = .dword } },
                        .{ .scalar_signed_int = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i32, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .yword } } },
                        .{ .type = .vector_8_i32, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_d, .sub, .dst0y, .src0y, .src1y, ._ },
                        .{ ._, .vp_d, .maxs, .dst0y, .dst0y, .lea(.tmp0y), ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                        .{ ._, .vp_d, .mins, .dst0y, .dst0y, .lea(.tmp0y), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .to_sse, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .maxu, .dst0x, .src1x, .src0x, ._ },
                        .{ ._, .vp_d, .sub, .dst0x, .dst0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_d, .maxu, .src0x, .src1x, ._, ._ },
                        .{ ._, .p_d, .sub, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .yword, .is = .dword } },
                        .{ .scalar_unsigned_int = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .to_sse, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .maxu, .dst0y, .src1y, .src0y, ._ },
                        .{ ._, .vp_d, .sub, .dst0y, .dst0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 64 } },
                        .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_i64, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ },
                        .{ ._, .vp_q, .sub, .dst0x, .src0x, .src1x, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp2x, .tmp2x, .src0x, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp3x, .dst0x, .src0x, ._ },
                        .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .lea(.tmp0x), ._ },
                        .{ ._, .vp_, .xor, .tmp3x, .tmp3x, .src1x, ._ },
                        .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .tmp2x, .tmp3x },
                    } },
                }, .{
                    .required_features = .{ .sse4_2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 64 } },
                        .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_i64, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, ._dqa, .mov, .dst0x, .src0x, ._, ._ },
                        .{ ._, .p_q, .sub, .dst0x, .src1x, ._, ._ },
                        .{ ._, .p_q, .cmpgt, .tmp2x, .src0x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp3x, .dst0x, ._, ._ },
                        .{ ._, .p_q, .cmpgt, .tmp3x, .src0x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, .p_, .xor, .tmp3x, .src1x, ._, ._ },
                        .{ ._, ._pd, .blendv, .dst0x, .tmp2x, .tmp3x, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_signed_int = .{ .of = .yword, .is = 64 } },
                        .{ .scalar_exact_signed_int = .{ .of = .yword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i64, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp2y, .tmp2y, .tmp2y, ._ },
                        .{ ._, .vp_q, .sub, .dst0y, .src0y, .src1y, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp2y, .tmp2y, .src0y, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp3y, .dst0y, .src0y, ._ },
                        .{ ._, .vp_, .xor, .tmp2y, .tmp2y, .lea(.tmp0y), ._ },
                        .{ ._, .vp_, .xor, .tmp3y, .tmp3y, .src1y, ._ },
                        .{ ._, .v_pd, .blendv, .dst0y, .dst0y, .tmp2y, .tmp3y },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_q, .broadcast, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, .vp_q, .sub, .dst0x, .src0x, .src1x, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp3x, .tmp2x, .dst0x, ._ },
                        .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp2x, .tmp3x },
                        .{ ._, .vp_q, .cmpeq, .tmp3x, .tmp3x, .tmp3x, ._ },
                        .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp3x, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp3x, .dst0x, .tmp2x, ._ },
                        .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp2x, .tmp3x },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, .vp_q, .sub, .dst0x, .src0x, .src1x, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp3x, .tmp2x, .dst0x, ._ },
                        .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp2x, .tmp3x },
                        .{ ._, .vp_q, .cmpeq, .tmp3x, .tmp3x, .tmp3x, ._ },
                        .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp3x, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp3x, .dst0x, .tmp2x, ._ },
                        .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp2x, .tmp3x },
                    } },
                }, .{
                    .required_features = .{ .sse4_2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, .p_q, .sub, .dst0x, .src1x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, .p_q, .cmpgt, .tmp3x, .dst0x, ._, ._ },
                        .{ ._, .p_b, .blendv, .dst0x, .tmp2x, .tmp3x, ._ },
                        .{ ._, .p_q, .cmpeq, .tmp3x, .tmp3x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .tmp3x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp3x, .dst0x, ._, ._ },
                        .{ ._, .p_q, .cmpgt, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, .p_b, .blendv, .dst0x, .tmp2x, .tmp3x, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .yword, .is = .qword } },
                        .{ .scalar_signed_int = .{ .of = .yword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ },
                        .{ ._, .vp_q, .sub, .dst0y, .src0y, .src1y, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp3y, .tmp2y, .dst0y, ._ },
                        .{ ._, .vp_b, .blendv, .dst0y, .dst0y, .tmp2y, .tmp3y },
                        .{ ._, .vp_q, .cmpeq, .tmp3y, .tmp3y, .tmp3y, ._ },
                        .{ ._, .vp_, .xor, .tmp2y, .tmp2y, .tmp3y, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp3y, .dst0y, .tmp2y, ._ },
                        .{ ._, .vp_b, .blendv, .dst0y, .dst0y, .tmp2y, .tmp3y },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_q, .broadcast, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, .vp_, .xor, .dst0x, .src0x, .tmp2x, ._ },
                        .{ ._, .vp_, .xor, .tmp2x, .src1x, .tmp2x, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp2x, .dst0x, .tmp2x, ._ },
                        .{ ._, .vp_q, .sub, .dst0x, .src0x, .src1x, ._ },
                        .{ ._, .vp_, .@"and", .dst0x, .dst0x, .tmp2x, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, .vp_, .xor, .dst0x, .src0x, .tmp2x, ._ },
                        .{ ._, .vp_, .xor, .tmp2x, .src1x, .tmp2x, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp2x, .dst0x, .tmp2x, ._ },
                        .{ ._, .vp_q, .sub, .dst0x, .src0x, .src1x, ._ },
                        .{ ._, .vp_, .@"and", .dst0x, .dst0x, .tmp2x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp3x, .src0x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .src1x, ._, ._ },
                        .{ ._, .p_q, .cmpgt, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, .p_q, .sub, .dst0x, .src1x, ._, ._ },
                        .{ ._, .p_, .@"and", .dst0x, .tmp3x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_unsigned_int = .{ .of = .yword, .is = 64 } },
                        .{ .scalar_exact_unsigned_int = .{ .of = .yword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ },
                        .{ ._, .vp_, .xor, .dst0y, .src0y, .tmp2y, ._ },
                        .{ ._, .vp_, .xor, .tmp2y, .src1y, .tmp2y, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp2y, .dst0y, .tmp2y, ._ },
                        .{ ._, .vp_q, .sub, .dst0y, .src0y, .src1y, ._ },
                        .{ ._, .vp_, .@"and", .dst0y, .dst0y, .tmp2y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_, .xor, .tmp0x, .tmp0x, .tmp0x, ._ },
                        .{ ._, .vp_q, .sub, .dst0x, .src0x, .src1x, ._ },
                        .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .tmp0x, .dst0x },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .xmm0 }, .mem, .none } },
                        .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ },
                        .{ ._, .p_q, .sub, .dst0x, .src1x, ._, ._ },
                        .{ ._, ._pd, .blendv, .dst0x, .tmp0x, .dst0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .yword, .is = .qword } },
                        .{ .scalar_unsigned_int = .{ .of = .yword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_, .xor, .tmp0y, .tmp0y, .tmp0y, ._ },
                        .{ ._, .vp_q, .sub, .dst0y, .src0y, .src1y, ._ },
                        .{ ._, .v_pd, .blendv, .dst0y, .dst0y, .tmp0y, .dst0y },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_int = .{ .of = .yword, .is = 1 } },
                        .{ .multiple_scalar_exact_int = .{ .of = .yword, .is = 1 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_, .andn, .tmp1y, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_int = .{ .of = .xword, .is = 1 } },
                        .{ .multiple_scalar_exact_int = .{ .of = .xword, .is = 1 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_, .andn, .tmp1x, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_int = .{ .of = .xword, .is = 1 } },
                        .{ .multiple_scalar_exact_int = .{ .of = .xword, .is = 1 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_, .andn, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_int = .{ .of = .xword, .is = 1 } },
                        .{ .multiple_scalar_exact_int = .{ .of = .xword, .is = 1 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._ps, .andn, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .mmx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_int = .{ .of = .qword, .is = 1 } },
                        .{ .multiple_scalar_exact_int = .{ .of = .qword, .is = 1 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u8, .kind = .{ .rc = .mmx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._q, .mov, .tmp1q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_, .andn, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .yword, .is = 8 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .yword, .is = 8 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_b, .subs, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 8 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 8 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_b, .subs, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 8 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 8 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_b, .subs, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .mmx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 8 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 8 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i8, .kind = .{ .rc = .mmx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._q, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_b, .subs, .tmp1q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 8 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 8 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2b, .ui(7), ._, ._ },
                        .{ ._, ._, .xor, .tmp2b, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .sub, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 8 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 8 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2b, .ui(7), ._, ._ },
                        .{ ._, ._, .xor, .tmp2b, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .sub, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 8 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 8 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._no, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1b, .ui(7), ._, ._ },
                        .{ ._, ._, .xor, .tmp1b, .sa(.src0, .add_smin), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 8 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 8 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._no, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1b, .ui(7), ._, ._ },
                        .{ ._, ._, .xor, .tmp1b, .sa(.src0, .add_smin), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_b, .cmpeq, .tmp2y, .tmp2y, .tmp2y, ._ },
                        .{ ._, .vp_b, .broadcast, .tmp3y, .lea(.tmp0b), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp2y, .tmp3y, .tmp2y, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp4y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_b, .sub, .tmp4y, .tmp4y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .vp_b, .maxs, .tmp4y, .tmp4y, .tmp3y, ._ },
                        .{ ._, .vp_b, .mins, .tmp4y, .tmp4y, .tmp2y, ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp4y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_i8, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_b, .cmpeq, .tmp2x, .tmp2x, .tmp2x, ._ },
                        .{ ._, .v_dqa, .mov, .tmp3x, .lea(.tmp0x), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp2x, .tmp3x, .tmp2x, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_b, .sub, .tmp4x, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .vp_b, .maxs, .tmp4x, .tmp4x, .tmp3x, ._ },
                        .{ ._, .vp_b, .mins, .tmp4x, .tmp4x, .tmp2x, ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_i8, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_b, .cmpeq, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp3x, .lea(.tmp0x), ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .tmp3x, ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_b, .sub, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_b, .maxs, .tmp4x, .tmp3x, ._, ._ },
                        .{ ._, .p_b, .mins, .tmp4x, .tmp2x, ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_i8, .kind = .{ .slimit_delta_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_b, .sub, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, .p_b, .subs, .tmp3x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_b, .add, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, .p_b, .adds, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, .p_b, .sub, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2b, .ui(7), ._, ._ },
                        .{ ._, ._, .sub, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp2b, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .sia(-1 << 7, .src0, .sub_smin), ._, ._ },
                        .{ ._, ._po, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2b, .ui(7), ._, ._ },
                        .{ ._, ._, .sub, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp2b, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .sia(-1 << 7, .src0, .sub_smin), ._, ._ },
                        .{ ._, ._po, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .sia(-1 << 7, .src0, .sub_smin), ._, ._ },
                        .{ ._, ._pe, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1b, .ui(7), ._, ._ },
                        .{ ._, ._, .xor, .tmp1b, .sa(.src0, .add_smax), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .sia(-1 << 7, .src0, .sub_smin), ._, ._ },
                        .{ ._, ._pe, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1b, .ui(7), ._, ._ },
                        .{ ._, ._, .xor, .tmp1b, .sa(.src0, .add_smax), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_b, .subus, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_b, .subus, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_b, .subus, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .mmx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u8, .kind = .{ .rc = .mmx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._q, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_b, .subus, .tmp1q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp2b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._c, .cmov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp2b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._c, .cmov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .cmc, ._, ._, ._, ._ },
                        .{ ._, ._, .sbb, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._, .@"and", .tmp1b, .tmp2b, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .cmc, ._, ._, ._, ._ },
                        .{ ._, ._, .sbb, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._, .@"and", .tmp1b, .tmp2b, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .yword, .is = 16 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .yword, .is = 16 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .subs, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 16 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 16 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .subs, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 16 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 16 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_w, .subs, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .fast_imm16, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 16 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 16 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .tmp2w, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .sub, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 16 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 16 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .sub, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 16 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 16 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._no, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .tmp1w, .sa(.src0, .add_smax), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 16 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 16 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._no, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .sa(.src0, .add_smax), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } },
                        .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_w, .cmpeq, .tmp2y, .tmp2y, .tmp2y, ._ },
                        .{ ._, .vp_w, .broadcast, .tmp3y, .lea(.tmp0w), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp2y, .tmp3y, .tmp2y, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp4y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .sub, .tmp4y, .tmp4y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .vp_w, .maxs, .tmp4y, .tmp4y, .tmp3y, ._ },
                        .{ ._, .vp_w, .mins, .tmp4y, .tmp4y, .tmp2y, ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp4y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } },
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i16, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_w, .cmpeq, .tmp2x, .tmp2x, .tmp2x, ._ },
                        .{ ._, .v_dqa, .mov, .tmp3x, .lea(.tmp0x), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp2x, .tmp3x, .tmp2x, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .sub, .tmp4x, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .vp_w, .maxs, .tmp4x, .tmp4x, .tmp3x, ._ },
                        .{ ._, .vp_w, .mins, .tmp4x, .tmp4x, .tmp2x, ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } },
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i16, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_w, .cmpeq, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp3x, .lea(.tmp0x), ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .tmp3x, ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_w, .sub, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_w, .maxs, .tmp4x, .tmp3x, ._, ._ },
                        .{ ._, .p_w, .mins, .tmp4x, .tmp2x, ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .fast_imm16, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 15 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 15 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ },
                        .{ ._, ._, .sub, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp2w, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp3w, .tmp3w, ._, ._ },
                        .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 15 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 15 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ },
                        .{ ._, ._, .sub, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp3w, .tmp3w, ._, ._ },
                        .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 15 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 15 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp2w, .tmp2w, ._, ._ },
                        .{ ._, ._no, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .tmp1w, .sa(.src0, .add_smax), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 15 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 15 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp2w, .tmp2w, ._, ._ },
                        .{ ._, ._no, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .sa(.src0, .add_smax), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi2, .cmov, .fast_imm16, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ },
                        .{ ._, ._, .sub, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp2w, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._rx, .ro, .tmp3d, .tmp1d, .uia(1, .src0, .add_bit_size_rem_64), ._ },
                        .{ ._, ._, .add, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi2, .cmov, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ },
                        .{ ._, ._, .sub, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._rx, .ro, .tmp3d, .tmp1d, .uia(1, .src0, .add_bit_size_rem_64), ._ },
                        .{ ._, ._, .add, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .fast_imm16, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ },
                        .{ ._, ._, .sub, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp2w, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp3d, .uia(31, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .add, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ },
                        .{ ._, ._, .sub, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp3d, .uia(31, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .add, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp2d, .uia(31, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .add, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._no, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .tmp1w, .sa(.src0, .add_smax), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp2d, .uia(31, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .add, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._no, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .sa(.src0, .add_smax), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .mmx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .word } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i16, .kind = .{ .rc = .mmx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._q, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_w, .subus, .tmp1q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .word } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .subus, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .subus, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_w, .subus, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .mmx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .word } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u16, .kind = .{ .rc = .mmx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._q, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_w, .subus, .tmp1q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp2w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._c, .cmov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .cmc, ._, ._, ._, ._ },
                        .{ ._, ._, .sbb, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._, .@"and", .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .yword, .is = 32 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .yword, .is = 32 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_d, .broadcast, .tmp2y, .lea(.tmp0d), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp4y, .memia(.src1y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_d, .sub, .tmp5y, .tmp3y, .tmp4y, ._ },
                        .{ ._, .vp_d, .sra, .tmp6y, .tmp3y, .ui(31), ._ },
                        .{ ._, .vp_d, .cmpgt, .tmp3y, .tmp5y, .tmp3y, ._ },
                        .{ ._, .vp_, .xor, .tmp6y, .tmp6y, .tmp2y, ._ },
                        .{ ._, .vp_, .xor, .tmp3y, .tmp3y, .tmp4y, ._ },
                        .{ ._, .v_ps, .blendv, .tmp3y, .tmp5y, .tmp6y, .tmp3y },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp3y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 32 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 32 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_ss, .broadcast, .tmp2x, .lea(.tmp0d), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_d, .sub, .tmp5x, .tmp3x, .tmp4x, ._ },
                        .{ ._, .vp_d, .sra, .tmp6x, .tmp3x, .ui(31), ._ },
                        .{ ._, .vp_d, .cmpgt, .tmp3x, .tmp5x, .tmp3x, ._ },
                        .{ ._, .vp_, .xor, .tmp6x, .tmp6x, .tmp2x, ._ },
                        .{ ._, .vp_, .xor, .tmp3x, .tmp3x, .tmp4x, ._ },
                        .{ ._, .v_ps, .blendv, .tmp3x, .tmp5x, .tmp6x, .tmp3x },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 32 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 32 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i32, .kind = .{ .reg = .xmm0 } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp5x, .tmp3x, ._, ._ },
                        .{ ._, .p_d, .sub, .tmp5x, .tmp4x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp6x, .tmp3x, ._, ._ },
                        .{ ._, .p_d, .sra, .tmp6x, .ui(31), ._, ._ },
                        .{ ._, .p_d, .cmpgt, .tmp3x, .tmp5x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp6x, .tmp2x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp3x, .tmp4x, ._, ._ },
                        .{ ._, ._ps, .blendv, .tmp6x, .tmp5x, .tmp3x, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp6x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .dword, .is = 32 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .dword, .is = 32 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .dword, .is = 32 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .dword, .is = 32 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._no, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .sa(.src0, .add_smin), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_d, .cmpeq, .tmp2y, .tmp2y, .tmp2y, ._ },
                        .{ ._, .vp_d, .broadcast, .tmp3y, .lea(.tmp0d), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp2y, .tmp3y, .tmp2y, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp4y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_d, .sub, .tmp4y, .tmp4y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .vp_d, .maxs, .tmp4y, .tmp4y, .tmp3y, ._ },
                        .{ ._, .vp_d, .mins, .tmp4y, .tmp4y, .tmp2y, ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp4y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_d, .cmpeq, .tmp2x, .tmp2x, .tmp2x, ._ },
                        .{ ._, .v_ss, .broadcast, .tmp3x, .lea(.tmp0d), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp2x, .tmp3x, .tmp2x, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_d, .sub, .tmp4x, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .vp_d, .maxs, .tmp4x, .tmp4x, .tmp3x, ._ },
                        .{ ._, .vp_d, .mins, .tmp4x, .tmp4x, .tmp2x, ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_d, .cmpeq, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp3x, .lea(.tmp0x), ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .tmp3x, ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_d, .sub, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_d, .maxs, .tmp4x, .tmp3x, ._, ._ },
                        .{ ._, .p_d, .mins, .tmp4x, .tmp2x, ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .dword, .is = 31 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .dword, .is = 31 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .dword, .is = 31 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .dword, .is = 31 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._no, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .sa(.src0, .add_smax), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi2, .cmov, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._rx, .ro, .tmp3d, .tmp1d, .uia(1, .src0, .add_bit_size_rem_64), ._ },
                        .{ ._, ._, .add, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp3d, .uia(31, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .add, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp2d, .uia(31, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .add, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._no, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .sa(.src0, .add_smax), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_d, .maxu, .tmp2y, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .vp_d, .sub, .tmp1y, .tmp2y, .tmp1y, ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_d, .maxu, .tmp2x, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .vp_d, .sub, .tmp1x, .tmp2x, .tmp1x, ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ },
                        .{ ._, .p_d, .maxu, .tmp2x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_d, .sub, .tmp2x, .tmp1x, ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp2d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._c, .cmov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .cmc, ._, ._, ._, ._ },
                        .{ ._, ._, .sbb, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._, .@"and", .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .yword, .is = 64 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .yword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp4y, .memia(.src1y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp5y, .tmp5y, .tmp5y, ._ },
                        .{ ._, .vp_q, .sub, .tmp6y, .tmp3y, .tmp4y, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp5y, .tmp5y, .tmp3y, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp3y, .tmp6y, .tmp3y, ._ },
                        .{ ._, .vp_, .xor, .tmp5y, .tmp5y, .tmp2y, ._ },
                        .{ ._, .vp_, .xor, .tmp3y, .tmp3y, .tmp4y, ._ },
                        .{ ._, .v_pd, .blendv, .tmp5y, .tmp6y, .tmp5y, .tmp3y },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp5y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 64 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp5x, .tmp5x, .tmp5x, ._ },
                        .{ ._, .vp_q, .sub, .tmp6x, .tmp3x, .tmp4x, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp5x, .tmp5x, .tmp3x, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp3x, .tmp6x, .tmp3x, ._ },
                        .{ ._, .vp_, .xor, .tmp5x, .tmp5x, .tmp2x, ._ },
                        .{ ._, .vp_, .xor, .tmp3x, .tmp3x, .tmp4x, ._ },
                        .{ ._, .v_pd, .blendv, .tmp5x, .tmp6x, .tmp5x, .tmp3x },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp5x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 64 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_, .xor, .tmp5x, .tmp5x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp6x, .tmp3x, ._, ._ },
                        .{ ._, .p_q, .sub, .tmp6x, .tmp4x, ._, ._ },
                        .{ ._, .p_q, .cmpgt, .tmp5x, .tmp3x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp7x, .tmp6x, ._, ._ },
                        .{ ._, .p_q, .cmpgt, .tmp7x, .tmp3x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp5x, .tmp2x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp7x, .tmp4x, ._, ._ },
                        .{ ._, ._pd, .blendv, .tmp6x, .tmp5x, .tmp7x, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp6x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 64 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp2q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ ._, ._, .xor, .tmp3q, .tmp1q, ._, ._ },
                        .{ ._, ._, .sub, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._o, .cmov, .tmp2q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 64 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smin), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._no, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ },
                        .{ ._, ._, .xor, .tmp2q, .tmp1q, ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_q, .cmpeq, .tmp2y, .tmp2y, .tmp2y, ._ },
                        .{ ._, .vp_q, .broadcast, .tmp3y, .lea(.tmp0q), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp2y, .tmp3y, .tmp2y, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp4y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_q, .sub, .tmp4y, .tmp4y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp5y, .tmp3y, .tmp4y, ._ },
                        .{ ._, .vp_b, .blendv, .tmp4y, .tmp4y, .tmp3y, .tmp5y },
                        .{ ._, .vp_q, .cmpgt, .tmp5y, .tmp4y, .tmp2y, ._ },
                        .{ ._, .vp_b, .blendv, .tmp4y, .tmp4y, .tmp2y, .tmp5y },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp4y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_q, .cmpeq, .tmp2x, .tmp2x, .tmp2x, ._ },
                        .{ ._, .v_, .movddup, .tmp3x, .lea(.tmp0q), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp2x, .tmp3x, .tmp2x, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_q, .sub, .tmp4x, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp5x, .tmp3x, .tmp4x, ._ },
                        .{ ._, .vp_b, .blendv, .tmp4x, .tmp4x, .tmp3x, .tmp5x },
                        .{ ._, .vp_q, .cmpgt, .tmp5x, .tmp4x, .tmp2x, ._ },
                        .{ ._, .vp_b, .blendv, .tmp4x, .tmp4x, .tmp2x, .tmp5x },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_q, .cmpeq, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, ._, .movddup, .tmp3x, .lea(.tmp0q), ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .tmp3x, ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_q, .sub, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp5x, .tmp3x, ._, ._ },
                        .{ ._, .p_q, .cmpgt, .tmp5x, .tmp4x, ._, ._ },
                        .{ ._, .p_b, .blendv, .tmp4x, .tmp3x, .tmp5x, ._ },
                        .{ ._, ._dqa, .mov, .tmp5x, .tmp4x, ._, ._ },
                        .{ ._, .p_q, .cmpgt, .tmp5x, .tmp2x, ._, ._ },
                        .{ ._, .p_b, .blendv, .tmp4x, .tmp2x, .tmp5x, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 63 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 63 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp2q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ ._, ._, .sub, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp3q, .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._, .add, .tmp4q, .tmp4q, ._, ._ },
                        .{ ._, ._o, .cmov, .tmp2q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 63 } },
                        .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 63 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp2q, ._, ._ },
                        .{ ._, ._, .add, .tmp3q, .tmp3q, ._, ._ },
                        .{ ._, ._no, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ },
                        .{ ._, ._, .xor, .tmp2q, .tmp1q, ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, .cmov, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp2q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ ._, ._, .sub, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp3q, .tmp1q, ._, ._ },
                        .{ ._, ._rx, .ro, .tmp4q, .tmp2q, .sia(-31, .src0, .add_bit_size_rem_64), ._ },
                        .{ ._, ._, .add, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._o, .cmov, .tmp2q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp2q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ ._, ._, .sub, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp3q, .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp4q, .sia(-31, .src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .add, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._o, .cmov, .tmp2q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp2q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .sia(-31, .src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .add, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._no, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ },
                        .{ ._, ._, .xor, .tmp2q, .tmp1q, ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .yword, .is = 64 } },
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .yword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp4y, .memia(.src1y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_q, .sub, .tmp5y, .tmp3y, .tmp4y, ._ },
                        .{ ._, .vp_, .xor, .tmp3y, .tmp3y, .tmp2y, ._ },
                        .{ ._, .vp_, .xor, .tmp4y, .tmp4y, .tmp2y, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp3y, .tmp3y, .tmp4y, ._ },
                        .{ ._, .vp_, .@"and", .tmp3y, .tmp5y, .tmp3y, ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp3y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_q, .sub, .tmp5x, .tmp3x, .tmp4x, ._ },
                        .{ ._, .vp_, .xor, .tmp3x, .tmp3x, .tmp2x, ._ },
                        .{ ._, .vp_, .xor, .tmp4x, .tmp4x, .tmp2x, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp3x, .tmp3x, .tmp4x, ._ },
                        .{ ._, .vp_, .@"and", .tmp3x, .tmp5x, .tmp3x, ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp5x, .tmp3x, ._, ._ },
                        .{ ._, .p_q, .sub, .tmp5x, .tmp4x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp4x, .tmp2x, ._, ._ },
                        .{ ._, .p_q, .cmpgt, .tmp3x, .tmp4x, ._, ._ },
                        .{ ._, .p_, .@"and", .tmp3x, .tmp5x, ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .qword, .is = 64 } },
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .qword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._c, .cmov, .tmp2q, .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .qword, .is = 64 } },
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .qword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .cmc, ._, ._, ._, ._ },
                        .{ ._, ._, .sbb, .tmp2q, .tmp2q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp1q, .tmp2q, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .qword } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp1y, .tmp1y, .tmp1y, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp2y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_q, .sub, .tmp2y, .tmp2y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_pd, .blendv, .tmp2y, .tmp2y, .tmp1y, .tmp2y },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp2y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp2x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_q, .sub, .tmp2x, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_pd, .blendv, .tmp2x, .tmp2x, .tmp1x, .tmp2x },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .reg = .xmm0 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp2x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_q, .sub, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._pd, .blendv, .tmp2x, .tmp1x, .tmp2x, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp1q, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._c, .cmov, .tmp2q, .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .cmc, ._, ._, ._, ._ },
                        .{ ._, ._, .sbb, .tmp2q, .tmp2q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp1q, .tmp2q, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_remainder_signed_int = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_exact_remainder_signed_int = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .reg = .rcx } },
                        .{ .type = .i64, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memiad(.src0, .tmp0, .add_unaligned_size_add_elem_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memiad(.src1, .tmp0, .add_unaligned_size_add_elem_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .memiad(.dst0, .tmp0, .add_unaligned_size_add_elem_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp4p, .sia(1, .src0, .sub_elem_size_div_8), ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp5q, .leasi(.tmp1q, .@"8", .tmp4), ._, ._ },
                        .{ ._, ._, .sbb, .tmp5q, .leasi(.tmp2q, .@"8", .tmp4), ._, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp3q, .@"8", .tmp4), .tmp5q, ._, ._ },
                        .{ ._, ._c, .in, .tmp4p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .lea(.tmp1q), ._, ._ },
                        .{ ._, ._, .sbb, .tmp5q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._no, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaad(.tmp3, .sub_src0_elem_size, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp4d, .sia(-1, .src0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, ._r, .sa, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp4q, ._, ._ },
                        .{ .@"1:", ._, .mov, .lea(.tmp3q), .tmp5q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_remainder_signed_int = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_exact_remainder_signed_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .reg = .rcx } },
                        .{ .type = .i64, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memiad(.src0, .tmp0, .add_unaligned_size_add_elem_size, -16), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memiad(.src1, .tmp0, .add_unaligned_size_add_elem_size, -16), ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .memiad(.dst0, .tmp0, .add_unaligned_size_add_elem_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp4p, .sia(2, .src0, .sub_elem_size_div_8), ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp5q, .leasi(.tmp1q, .@"8", .tmp4), ._, ._ },
                        .{ ._, ._, .sbb, .tmp5q, .leasi(.tmp2q, .@"8", .tmp4), ._, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp3q, .@"8", .tmp4), .tmp5q, ._, ._ },
                        .{ ._, ._c, .in, .tmp4p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .lea(.tmp1q), ._, ._ },
                        .{ ._, ._, .sbb, .tmp5q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._no, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaad(.tmp3, .sub_src0_elem_size, 16), ._, ._ },
                        .{ ._, ._, .mov, .tmp4d, .sia(-2, .src0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, ._r, .sa, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp4q, ._, ._ },
                        .{ .@"1:", ._, .mov, .lea(.tmp3q), .tmp5q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .lead(.tmp3q, 8), .tmp5q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .reg = .rcx } },
                        .{ .type = .i64, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memiad(.src0, .tmp0, .add_unaligned_size_add_elem_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memiad(.src1, .tmp0, .add_unaligned_size_add_elem_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .memiad(.dst0, .tmp0, .add_unaligned_size_add_elem_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp4p, .sia(1, .src0, .sub_elem_size_div_8), ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp5q, .leasi(.tmp1q, .@"8", .tmp4), ._, ._ },
                        .{ ._, ._, .sbb, .tmp5q, .leasi(.tmp2q, .@"8", .tmp4), ._, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp3q, .@"8", .tmp4), .tmp5q, ._, ._ },
                        .{ ._, ._c, .in, .tmp4p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._l, .sa, .tmp5q, .uia(63, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .add, .tmp5q, .tmp5q, ._, ._ },
                        .{ ._, ._no, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaad(.tmp3, .sub_src0_elem_size, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp4d, .sia(-2, .src0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, ._r, .sa, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .lead(.tmp3q, -8), .tmp5q, ._, ._ },
                        .{ .@"1:", ._r, .sa, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .lea(.tmp3q), .tmp5q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .reg = .rcx } },
                        .{ .type = .i64, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memia(.src1, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .memia(.dst0, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp4p, .sa(.src0, .sub_elem_size_div_8), ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp5q, .leasi(.tmp1q, .@"8", .tmp4), ._, ._ },
                        .{ ._, ._, .sbb, .tmp5q, .leasi(.tmp2q, .@"8", .tmp4), ._, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp3q, .@"8", .tmp4), .tmp5q, ._, ._ },
                        .{ ._, ._c, .in, .tmp4p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._l, .sa, .tmp5q, .uia(63, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .add, .tmp5q, .tmp5q, ._, ._ },
                        .{ ._, ._no, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp3, .sub_src0_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp4d, .sia(-1, .src0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, ._r, .sa, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .lead(.tmp3q, -8), .tmp5q, ._, ._ },
                        .{ .@"1:", ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .scalar_remainder_unsigned_int = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_remainder_unsigned_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp2p, .memia(.src0, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .memia(.src1, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp4p, .memia(.dst0, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp5p, .sa(.src0, .sub_elem_size_div_8), ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .sbb, .tmp6q, .leasi(.tmp3q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp4q, .@"8", .tmp5), .tmp6q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._nc, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp5p, .leaa(.tmp4, .sub_src0_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .sa(.src0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ .@"1:", ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f} {f}", .{
                        @tagName(air_tag),
                        cg.typeOf(bin_op.lhs).fmt(pt),
                        ops[0].tracking(cg),
                        ops[1].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
            },
            .mul, .mul_optimized => |air_tag| {
                const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                const ty = cg.typeOf(bin_op.lhs);
                var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                var res: [1]Temp = undefined;
                cg.select(&res, &.{ty}, &ops, comptime &.{ .{
                    .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .al }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .al }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .al }, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .i_, .mul, .src1b, ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .al }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .al }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .al }, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mul, .src1b, ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .int = .word }, .{ .int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .imm16, .none } },
                        .{ .src = .{ .imm16, .mem, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_gpr, .imm16, .none } },
                        .{ .src = .{ .imm16, .to_gpr, .none }, .commute = .{ 0, 1 } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .i_, .mul, .dst0w, .src0w, .src1w, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .int = .word }, .{ .int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .i_, .mul, .dst0w, .src1w, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .int = .dword }, .{ .int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .imm32, .none } },
                        .{ .src = .{ .imm32, .mem, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_gpr, .imm32, .none } },
                        .{ .src = .{ .imm32, .to_gpr, .none }, .commute = .{ 0, 1 } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .i_, .mul, .dst0d, .src0d, .src1d, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .int = .dword }, .{ .int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .i_, .mul, .dst0d, .src1d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .int = .qword }, .{ .int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .simm32, .none } },
                        .{ .src = .{ .simm32, .mem, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_gpr, .simm32, .none } },
                        .{ .src = .{ .simm32, .to_gpr, .none }, .commute = .{ 0, 1 } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .i_, .mul, .dst0q, .src0q, .src1q, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .int = .qword }, .{ .int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .i_, .mul, .dst0q, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .int = .xword }, .{ .int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ },
                        .{ ._, ._, .mul, .src1q, ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ },
                        .{ ._, .i_, .mul, .tmp0q, .memd(.src1q, 8), ._, ._ },
                        .{ ._, ._, .add, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .src1q, ._, ._ },
                        .{ ._, .i_, .mul, .tmp0q, .memd(.src0q, 8), ._, ._ },
                        .{ ._, ._, .add, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, .adx, null },
                    .src_constraints = .{
                        .{ .remainder_int = .{ .of = .qword, .is = .qword } },
                        .{ .remainder_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .isize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                        .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._z, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .leaad(.tmp0, .sub_src0_size, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ .@"1:", ._x, .mul, .tmp6q, .tmp5q, .leai(.tmp1q, .tmp3), ._ },
                        .{ ._, ._x, .adc, .tmp5q, .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .memiad(.dst0q, .tmp3, .add_size, -8), .tmp5q, ._, ._ },
                        .{ ._, ._rcxz, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._x, .ado, .tmp6q, .memia(.dst0q, .tmp3, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp6q, ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .lead(.tmp3, 8), ._, ._ },
                        .{ ._, ._mp, .j, .@"1b", ._, ._, ._ },
                        .{ .@"2:", ._, .mov, .memi(.dst0q, .tmp0), .tmp2q, ._, ._ },
                        .{ .@"1:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, .slow_incdec, null },
                    .src_constraints = .{
                        .{ .remainder_int = .{ .of = .qword, .is = .qword } },
                        .{ .remainder_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp2p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp3q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp7q, .memsia(.dst0q, .@"8", .tmp2, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp4b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._l, .sh, .tmp4b, .ui(4), ._, ._ },
                        .{ .@"2:", ._x, .mul, .tmp7q, .tmp6q, .leasi(.tmp1q, .@"8", .tmp2), ._ },
                        .{ ._, ._, .adc, .tmp6q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp2, .add_size), .tmp6q, ._, ._ },
                        .{ ._, ._c, .in, .tmp2p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, null, null },
                    .src_constraints = .{
                        .{ .remainder_int = .{ .of = .qword, .is = .qword } },
                        .{ .remainder_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp2p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp3q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp7q, .memsia(.dst0q, .@"8", .tmp2, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp4b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._l, .sh, .tmp4b, .ui(4), ._, ._ },
                        .{ .@"2:", ._x, .mul, .tmp7q, .tmp6q, .leasi(.tmp1q, .@"8", .tmp2), ._ },
                        .{ ._, ._, .adc, .tmp6q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp2, .add_size), .tmp6q, ._, ._ },
                        .{ ._, ._c, .in, .tmp2p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .remainder_int = .{ .of = .qword, .is = .qword } },
                        .{ .remainder_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp2p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp3q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp7q, .memsia(.dst0q, .@"8", .tmp2, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp4b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp7q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .leasi(.tmp1q, .@"8", .tmp2), ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp4b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp6q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp2, .add_size), .tmp6q, ._, ._ },
                        .{ ._, ._c, .in, .tmp2p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_int = .{ .of = .qword, .is = .qword } },
                        .{ .remainder_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp2p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp3q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp7q, .memsia(.dst0q, .@"8", .tmp2, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp4b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp7q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .leasi(.tmp1q, .@"8", .tmp2), ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp4b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp6q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp2, .add_size), .tmp6q, ._, ._ },
                        .{ ._, ._c, .in, .tmp2p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .qword, .is = .byte } },
                        .{ .scalar_signed_int = .{ .of = .qword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_8_i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .movsxb, .dst0x, .src0q, ._, ._ },
                        .{ ._, .vp_w, .movsxb, .tmp0x, .src1q, ._, ._ },
                        .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp0x, ._ },
                        .{ ._, .vp_b, .ackssw, .dst0x, .dst0x, .dst0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .qword, .is = .byte } },
                        .{ .scalar_signed_int = .{ .of = .qword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_8_i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_w, .movsxb, .dst0x, .src0q, ._, ._ },
                        .{ ._, .p_w, .movsxb, .tmp0x, .src1q, ._, ._ },
                        .{ ._, .p_w, .mull, .dst0x, .tmp0x, ._, ._ },
                        .{ ._, .p_b, .ackssw, .dst0x, .dst0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .qword, .is = .byte } },
                        .{ .scalar_signed_int = .{ .of = .qword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .to_mut_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ },
                        .{ ._, .p_b, .cmpgt, .tmp0x, .src0x, ._, ._ },
                        .{ ._, .p_, .unpcklbw, .dst0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ },
                        .{ ._, .p_b, .cmpgt, .tmp0x, .src1x, ._, ._ },
                        .{ ._, .p_, .unpcklbw, .src1x, .tmp0x, ._, ._ },
                        .{ ._, .p_w, .mull, .dst0x, .src1x, ._, ._ },
                        .{ ._, .p_b, .ackssw, .dst0x, .dst0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .movsxb, .dst0y, .src0x, ._, ._ },
                        .{ ._, .vp_w, .movsxb, .tmp0y, .src1x, ._, ._ },
                        .{ ._, .vp_w, .mull, .dst0y, .dst0y, .tmp0y, ._ },
                        .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                        .{ ._, .vp_b, .ackssw, .dst0x, .dst0x, .tmp0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } },
                        .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_8_u16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .movzxb, .dst0x, .src0q, ._, ._ },
                        .{ ._, .vp_w, .movzxb, .tmp0x, .src1q, ._, ._ },
                        .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp0x, ._ },
                        .{ ._, .vp_b, .ackusw, .dst0x, .dst0x, .dst0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } },
                        .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_8_u16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_w, .movzxb, .dst0x, .src0q, ._, ._ },
                        .{ ._, .p_w, .movzxb, .tmp0x, .src1q, ._, ._ },
                        .{ ._, .p_w, .mull, .dst0x, .tmp0x, ._, ._ },
                        .{ ._, .p_b, .ackusw, .dst0x, .dst0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } },
                        .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .to_mut_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpcklbw, .dst0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpcklbw, .src1x, .tmp0x, ._, ._ },
                        .{ ._, .p_w, .mull, .dst0x, .src1x, ._, ._ },
                        .{ ._, .p_b, .ackusw, .dst0x, .dst0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .movzxb, .dst0y, .src0x, ._, ._ },
                        .{ ._, .vp_w, .movzxb, .tmp0y, .src1x, ._, ._ },
                        .{ ._, .vp_w, .mull, .dst0y, .dst0y, .tmp0y, ._ },
                        .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                        .{ ._, .vp_b, .ackusw, .dst0x, .dst0x, .tmp0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_w, .movsxb, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .movsxb, .tmp2y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .mull, .tmp1y, .tmp1y, .tmp2y, ._ },
                        .{ ._, .v_i128, .extract, .tmp2x, .tmp1y, .ui(1), ._ },
                        .{ ._, .vp_b, .ackssw, .tmp1x, .tmp1x, .tmp2x, ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_w, .movsxb, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .movsxb, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .mull, .tmp1x, .tmp1x, .tmp2x, ._ },
                        .{ ._, .vp_b, .ackssw, .tmp1x, .tmp1x, .tmp1x, ._ },
                        .{ ._, .v_q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_w, .movsxb, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_w, .movsxb, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_w, .mull, .tmp1x, .tmp2x, ._, ._ },
                        .{ ._, .p_b, .ackssw, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._q, .mov, .tmp2x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_b, .cmpgt, .tmp1x, .tmp2x, ._, ._ },
                        .{ ._, .p_, .unpcklbw, .tmp2x, .tmp1x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._q, .mov, .tmp3x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_b, .cmpgt, .tmp1x, .tmp3x, ._, ._ },
                        .{ ._, .p_, .unpcklbw, .tmp3x, .tmp1x, ._, ._ },
                        .{ ._, .p_w, .mull, .tmp2x, .tmp3x, ._, ._ },
                        .{ ._, .p_b, .ackssw, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .reg = .al } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .i_, .mul, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .reg = .al } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .i_, .mul, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_w, .movzxb, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .movzxb, .tmp2y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .mull, .tmp1y, .tmp1y, .tmp2y, ._ },
                        .{ ._, .v_i128, .extract, .tmp2x, .tmp1y, .ui(1), ._ },
                        .{ ._, .vp_b, .ackusw, .tmp1x, .tmp1x, .tmp2x, ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_w, .movzxb, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .movzxb, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .mull, .tmp1x, .tmp1x, .tmp2x, ._ },
                        .{ ._, .vp_b, .ackusw, .tmp1x, .tmp1x, .tmp1x, ._ },
                        .{ ._, .v_q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_w, .movzxb, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_w, .movzxb, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_w, .mull, .tmp1x, .tmp2x, ._, ._ },
                        .{ ._, .p_b, .ackusw, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._q, .mov, .tmp2x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_, .unpcklbw, .tmp2x, .tmp1x, ._, ._ },
                        .{ ._, ._q, .mov, .tmp3x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_, .unpcklbw, .tmp3x, .tmp1x, ._, ._ },
                        .{ ._, .p_w, .mull, .tmp2x, .tmp3x, ._, ._ },
                        .{ ._, .p_b, .ackusw, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .reg = .al } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mul, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .reg = .al } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mul, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_int = .{ .of = .xword, .is = .word } },
                        .{ .scalar_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .mull, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_int = .{ .of = .xword, .is = .word } },
                        .{ .scalar_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_w, .mull, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_int = .{ .of = .yword, .is = .word } },
                        .{ .scalar_int = .{ .of = .yword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .mull, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .yword, .is = .word } },
                        .{ .multiple_scalar_int = .{ .of = .yword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .mull, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .word } },
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .mull, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .word } },
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_w, .mull, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .i_, .mul, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .i_, .mul, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_int = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .mull, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_int = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_d, .mull, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_int = .{ .of = .yword, .is = .dword } },
                        .{ .scalar_int = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .mull, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .yword, .is = .dword } },
                        .{ .multiple_scalar_int = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_d, .mull, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } },
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_d, .mull, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } },
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_d, .mull, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } },
                        .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .i_, .mul, .tmp1d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .i_, .mul, .tmp1q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, .adx, null },
                    .src_constraints = .{
                        .{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .isize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memia(.src1, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp4d, .sia(-8, .src0, .add_elem_size), ._, ._ },
                        .{ .@"1:", ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .leai(.tmp1q, .tmp4), ._, ._ },
                        .{ ._, ._z, .j, .@"3f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp6p, .leaad(.tmp4, .sub_src0_elem_size, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ .@"2:", ._x, .mul, .tmp9q, .tmp8q, .leai(.tmp2q, .tmp6), ._ },
                        .{ ._, ._x, .adc, .tmp8q, .tmp7q, ._, ._ },
                        .{ ._, ._, .mov, .leaiad(.tmp3q, .tmp6, .add_dst0_elem_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._rcxz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._x, .ado, .tmp9q, .leaia(.tmp3q, .tmp6, .add_dst0_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp9q, ._, ._ },
                        .{ ._, ._, .lea, .tmp6p, .lead(.tmp6, 8), ._, ._ },
                        .{ ._, ._mp, .j, .@"2b", ._, ._, ._ },
                        .{ .@"3:", ._, .mov, .leai(.tmp3q, .tmp4), .tmp5q, ._, ._ },
                        .{ .@"2:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp4d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, .slow_incdec, null },
                    .src_constraints = .{
                        .{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memiad(.src1, .tmp0, .add_unaligned_size, 8), ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp4d, .sia(-1, .src0, .add_elem_size_div_8), ._, ._ },
                        .{ .@"1:", ._, .lea, .tmp5p, .leaa(.tmp4, .sub_src0_elem_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp6q, .leasi(.tmp1q, .@"8", .tmp4), ._, ._ },
                        .{ ._, ._nz, .j, .@"3f", ._, ._, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp3q, .@"8", .tmp4), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"4f", ._, ._, ._ },
                        .{ .@"2:", ._, .adc, .tmp10q, .leasia(.tmp3q, .@"8", .tmp5, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ .@"3:", ._x, .mul, .tmp10q, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .leasia(.tmp3q, .@"8", .tmp5, .add_src0_elem_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"2b", ._, ._, ._ },
                        .{ .@"4:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp4d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, null, null },
                    .src_constraints = .{
                        .{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memiad(.src1, .tmp0, .add_unaligned_size, 8), ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp4d, .sia(-1, .src0, .add_elem_size_div_8), ._, ._ },
                        .{ .@"1:", ._, .lea, .tmp5p, .leaa(.tmp4, .sub_src0_elem_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp6q, .leasi(.tmp1q, .@"8", .tmp4), ._, ._ },
                        .{ ._, ._nz, .j, .@"3f", ._, ._, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp3q, .@"8", .tmp4), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"4f", ._, ._, ._ },
                        .{ .@"2:", ._, .adc, .tmp10q, .leasia(.tmp3q, .@"8", .tmp5, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ .@"3:", ._x, .mul, .tmp10q, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .leasia(.tmp3q, .@"8", .tmp5, .add_src0_elem_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"2b", ._, ._, ._ },
                        .{ .@"4:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp4d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memiad(.src1, .tmp0, .add_unaligned_size, 8), ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp4d, .sia(-1, .src0, .add_elem_size_div_8), ._, ._ },
                        .{ .@"1:", ._, .lea, .tmp5p, .leaa(.tmp4, .sub_src0_elem_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp6q, .leasi(.tmp1q, .@"8", .tmp4), ._, ._ },
                        .{ ._, ._nz, .j, .@"3f", ._, ._, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp3q, .@"8", .tmp4), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"4f", ._, ._, ._ },
                        .{ .@"2:", ._, .adc, .tmp10q, .leasia(.tmp3q, .@"8", .tmp5, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .mov, .tmp9q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mul, .leasi(.tmp2q, .@"8", .tmp5), ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .leasia(.tmp3q, .@"8", .tmp5, .add_src0_elem_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"2b", ._, ._, ._ },
                        .{ .@"4:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp4d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memiad(.src1, .tmp0, .add_unaligned_size, 8), ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp4d, .sia(-1, .src0, .add_elem_size_div_8), ._, ._ },
                        .{ .@"1:", ._, .lea, .tmp5p, .leaa(.tmp4, .sub_src0_elem_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp6q, .leasi(.tmp1q, .@"8", .tmp4), ._, ._ },
                        .{ ._, ._nz, .j, .@"3f", ._, ._, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp3q, .@"8", .tmp4), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"4f", ._, ._, ._ },
                        .{ .@"2:", ._, .adc, .tmp10q, .leasia(.tmp3q, .@"8", .tmp5, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .mov, .tmp9q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mul, .leasi(.tmp2q, .@"8", .tmp5), ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .leasia(.tmp3q, .@"8", .tmp5, .add_src0_elem_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"2b", ._, ._, ._ },
                        .{ .@"4:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp4d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
                        .{ ._, .v_ss, .mul, .dst0x, .dst0x, .tmp0d, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__mulhf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .word } },
                        .{ .scalar_float = .{ .of = .qword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_4_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
                        .{ ._, .v_ps, .mul, .dst0x, .dst0x, .tmp0x, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .word } },
                        .{ .scalar_float = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ },
                        .{ ._, .v_ps, .mul, .dst0y, .dst0y, .tmp0y, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_ps, .mul, .tmp1y, .tmp1y, .tmp2y, ._ },
                        .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__mulhf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ },
                        .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
                        .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0) },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__mulhf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                        .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__mulhf3" } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                        .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .tmp4d, .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__mulhf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ss, .mul, .dst0x, .src0x, .src1d, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._ss, .mul, .dst0x, .src1d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .mul, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._ps, .mul, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .yword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .mul, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_ps, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_ps, .mul, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._ps, .mul, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_sd, .mul, .dst0x, .src0x, .src1q, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._sd, .mul, .dst0x, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f64, .kind = .{ .reg = .st6 } },
                        .{ .type = .f64, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0q, ._, ._, ._ },
                        .{ ._, .f_, .mul, .src1q, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_pd, .mul, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._pd, .mul, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .yword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .yword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_pd, .mul, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_pd, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_pd, .mul, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._pd, .mul, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .reg = .st6 } },
                        .{ .type = .f64, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, .f_, .mul, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, .f_p, .st, .memia(.dst0q, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
                        .{ ._, .f_p, .mul, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .msvc,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
                        .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp3d, .memd(.tmp2b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_00_11), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp2b, 1), .tmp3b, ._, ._ },
                        .{ ._, .f_p, .mul, ._, ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .mem, .to_x87, .none } },
                        .{ .src = .{ .to_x87, .to_x87, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .f_, .mul, .tmp0t, .src1t, ._, ._ },
                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .msvc,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .mem, .to_x87, .none } },
                        .{ .src = .{ .to_x87, .to_x87, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_00_11), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
                        .{ ._, .f_, .mul, .tmp0t, .src1t, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, .f_p, .mul, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .msvc,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .fn_cw, .st, .tmp0w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp1d, .memd(.tmp0b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp0b, 1), .ui(0b000_0_00_11), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp0b, 1), .tmp1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp1, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, .f_, .ld, .memia(.src1t, .tmp1, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, .f_p, .mul, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .memia(.dst0t, .tmp1, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp2x, .memi(.src1x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .memi(.src1x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._ps, .mova, .tmp2x, .memi(.src1x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memi(.src1, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp4x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memi(.src1, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp4x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memi(.src1, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp4x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f} {f}", .{
                        @tagName(air_tag),
                        ty.fmt(pt),
                        ops[0].tracking(cg),
                        ops[1].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
            },
            .mul_safe => unreachable,
            .mul_wrap => |air_tag| {
                const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                const ty = cg.typeOf(bin_op.lhs);
                var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                var res: [1]Temp = undefined;
                cg.select(&res, &.{ty}, &ops, comptime &.{ .{
                    .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .al }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .al }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .al }, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .i_, .mul, .src1b, ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .al }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .al }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .al }, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mul, .src1b, ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .int = .word }, .{ .int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .imm16, .none } },
                        .{ .src = .{ .imm16, .mem, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_gpr, .imm16, .none } },
                        .{ .src = .{ .imm16, .to_gpr, .none }, .commute = .{ 0, 1 } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .i_, .mul, .dst0w, .src0w, .src1w, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .int = .word }, .{ .int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .i_, .mul, .dst0w, .src1w, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .int = .dword }, .{ .int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .imm32, .none } },
                        .{ .src = .{ .imm32, .mem, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_gpr, .imm32, .none } },
                        .{ .src = .{ .imm32, .to_gpr, .none }, .commute = .{ 0, 1 } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .i_, .mul, .dst0d, .src0d, .src1d, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .int = .dword }, .{ .int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .i_, .mul, .dst0d, .src1d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .int = .qword }, .{ .int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .simm32, .none } },
                        .{ .src = .{ .simm32, .mem, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_gpr, .simm32, .none } },
                        .{ .src = .{ .simm32, .to_gpr, .none }, .commute = .{ 0, 1 } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .i_, .mul, .dst0q, .src0q, .src1q, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .int = .qword }, .{ .int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .i_, .mul, .dst0q, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .int = .xword }, .{ .int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ },
                        .{ ._, ._, .mul, .src1q, ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ },
                        .{ ._, .i_, .mul, .tmp0q, .memd(.src1q, 8), ._, ._ },
                        .{ ._, ._, .add, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .src1q, ._, ._ },
                        .{ ._, .i_, .mul, .tmp0q, .memd(.src0q, 8), ._, ._ },
                        .{ ._, ._, .add, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, .adx, null },
                    .src_constraints = .{
                        .{ .remainder_int = .{ .of = .qword, .is = .qword } },
                        .{ .remainder_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .isize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                        .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._z, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .leaad(.tmp0, .sub_src0_size, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ .@"1:", ._x, .mul, .tmp6q, .tmp5q, .leai(.tmp1q, .tmp3), ._ },
                        .{ ._, ._x, .adc, .tmp5q, .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .memiad(.dst0q, .tmp3, .add_size, -8), .tmp5q, ._, ._ },
                        .{ ._, ._rcxz, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._x, .ado, .tmp6q, .memia(.dst0q, .tmp3, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp6q, ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .lead(.tmp3, 8), ._, ._ },
                        .{ ._, ._mp, .j, .@"1b", ._, ._, ._ },
                        .{ .@"2:", ._, .mov, .memi(.dst0q, .tmp0), .tmp2q, ._, ._ },
                        .{ .@"1:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, .slow_incdec, null },
                    .src_constraints = .{
                        .{ .remainder_int = .{ .of = .qword, .is = .qword } },
                        .{ .remainder_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp2p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp3q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp7q, .memsia(.dst0q, .@"8", .tmp2, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp4b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._l, .sh, .tmp4b, .ui(4), ._, ._ },
                        .{ .@"2:", ._x, .mul, .tmp7q, .tmp6q, .leasi(.tmp1q, .@"8", .tmp2), ._ },
                        .{ ._, ._, .adc, .tmp6q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp2, .add_size), .tmp6q, ._, ._ },
                        .{ ._, ._c, .in, .tmp2p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, null, null },
                    .src_constraints = .{
                        .{ .remainder_int = .{ .of = .qword, .is = .qword } },
                        .{ .remainder_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp2p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp3q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp7q, .memsia(.dst0q, .@"8", .tmp2, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp4b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._l, .sh, .tmp4b, .ui(4), ._, ._ },
                        .{ .@"2:", ._x, .mul, .tmp7q, .tmp6q, .leasi(.tmp1q, .@"8", .tmp2), ._ },
                        .{ ._, ._, .adc, .tmp6q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp2, .add_size), .tmp6q, ._, ._ },
                        .{ ._, ._c, .in, .tmp2p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .remainder_int = .{ .of = .qword, .is = .qword } },
                        .{ .remainder_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp2p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp3q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp7q, .memsia(.dst0q, .@"8", .tmp2, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp4b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp7q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .leasi(.tmp1q, .@"8", .tmp2), ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp4b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp6q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp2, .add_size), .tmp6q, ._, ._ },
                        .{ ._, ._c, .in, .tmp2p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_int = .{ .of = .qword, .is = .qword } },
                        .{ .remainder_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp2p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp3q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp7q, .memsia(.dst0q, .@"8", .tmp2, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp4b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp7q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .leasi(.tmp1q, .@"8", .tmp2), ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp4b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp6q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp2, .add_size), .tmp6q, ._, ._ },
                        .{ ._, ._c, .in, .tmp2p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .qword, .is = .byte } },
                        .{ .scalar_signed_int = .{ .of = .qword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .word, .to = .byte } } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ },
                        .{ ._, .vp_w, .movsxb, .dst0x, .src0q, ._, ._ },
                        .{ ._, .vp_w, .movsxb, .tmp2x, .src1q, ._, ._ },
                        .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                        .{ ._, .vp_b, .shuf, .dst0x, .dst0x, .lea(.tmp1x), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .qword, .is = .byte } },
                        .{ .scalar_signed_int = .{ .of = .qword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .word, .to = .byte } } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ },
                        .{ ._, .p_w, .movsxb, .dst0x, .src0q, ._, ._ },
                        .{ ._, .p_w, .movsxb, .tmp2x, .src1q, ._, ._ },
                        .{ ._, .p_w, .mull, .dst0x, .tmp2x, ._, ._ },
                        .{ ._, .p_b, .shuf, .dst0x, .lea(.tmp1x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_int = .{ .of = .qword, .is = .byte } },
                        .{ .scalar_int = .{ .of = .qword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .to_mut_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .pand_trunc_mem = .{ .from = .word, .to = .byte } } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ },
                        .{ ._, .p_, .unpcklbw, .dst0x, .dst0x, ._, ._ },
                        .{ ._, .p_, .unpcklbw, .src1x, .src1x, ._, ._ },
                        .{ ._, .p_w, .mull, .dst0x, .src1x, ._, ._ },
                        .{ ._, .p_, .@"and", .dst0x, .lea(.tmp1x), ._, ._ },
                        .{ ._, .p_b, .ackusw, .dst0x, .dst0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_32_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .word, .to = .byte } } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ },
                        .{ ._, .vp_w, .movsxb, .dst0y, .src0x, ._, ._ },
                        .{ ._, .vp_w, .movsxb, .tmp2y, .src1x, ._, ._ },
                        .{ ._, .vp_w, .mull, .dst0y, .dst0y, .tmp2y, ._ },
                        .{ ._, .vp_b, .shuf, .dst0y, .dst0y, .lea(.tmp1y), ._ },
                        .{ ._, .v_q, .perm, .dst0y, .dst0y, .ui(0b10_00_10_00), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } },
                        .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .word, .to = .byte } } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ },
                        .{ ._, .vp_w, .movzxb, .dst0x, .src0q, ._, ._ },
                        .{ ._, .vp_w, .movzxb, .tmp2x, .src1q, ._, ._ },
                        .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                        .{ ._, .vp_b, .shuf, .dst0x, .dst0x, .lea(.tmp1x), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } },
                        .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .word, .to = .byte } } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ },
                        .{ ._, .p_w, .movzxb, .dst0x, .src0q, ._, ._ },
                        .{ ._, .p_w, .movzxb, .tmp2x, .src1q, ._, ._ },
                        .{ ._, .p_w, .mull, .dst0x, .tmp2x, ._, ._ },
                        .{ ._, .p_b, .shuf, .dst0x, .lea(.tmp1x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_32_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .word, .to = .byte } } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ },
                        .{ ._, .vp_w, .movzxb, .dst0y, .src0x, ._, ._ },
                        .{ ._, .vp_w, .movzxb, .tmp2y, .src1x, ._, ._ },
                        .{ ._, .vp_w, .mull, .dst0y, .dst0y, .tmp2y, ._ },
                        .{ ._, .vp_b, .shuf, .dst0y, .dst0y, .lea(.tmp1y), ._ },
                        .{ ._, .v_q, .perm, .dst0y, .dst0y, .ui(0b10_00_10_00), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u8, .kind = .{ .pshufb_trunc_mem = .{ .of = .xword, .from = .word, .to = .byte } } },
                        .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_w, .movsxb, .tmp3y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .movsxb, .tmp4y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .mull, .tmp3y, .tmp3y, .tmp4y, ._ },
                        .{ ._, .vp_b, .shuf, .tmp3y, .tmp3y, .tmp2y, ._ },
                        .{ ._, .v_q, .perm, .tmp3y, .tmp3y, .ui(0b10_00_10_00), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u8, .kind = .{ .pshufb_trunc_mem = .{ .of = .xword, .from = .word, .to = .byte } } },
                        .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_w, .movsxb, .tmp3x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .movsxb, .tmp4x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .mull, .tmp3x, .tmp3x, .tmp4x, ._ },
                        .{ ._, .vp_b, .shuf, .tmp3x, .tmp3x, .tmp2x, ._ },
                        .{ ._, .v_q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u8, .kind = .{ .pshufb_trunc_mem = .{ .of = .xword, .from = .word, .to = .byte } } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_w, .movsxb, .tmp3x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_w, .movsxb, .tmp4x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_w, .mull, .tmp3x, .tmp4x, ._, ._ },
                        .{ ._, .p_b, .shuf, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .ssse3, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .qword, .is = .byte } },
                        .{ .multiple_scalar_int = .{ .of = .qword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u8, .kind = .{ .pshufb_trunc_mem = .{ .of = .xword, .from = .word, .to = .byte } } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._q, .mov, .tmp3x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_, .unpcklbw, .tmp3x, .tmp3x, ._, ._ },
                        .{ ._, ._q, .mov, .tmp4x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_, .unpcklbw, .tmp4x, .tmp4x, ._, ._ },
                        .{ ._, .p_w, .mull, .tmp3x, .tmp4x, ._, ._ },
                        .{ ._, .p_b, .shuf, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse3, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .qword, .is = .byte } },
                        .{ .multiple_scalar_int = .{ .of = .qword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u8, .kind = .{ .pand_trunc_mem = .{ .from = .word, .to = .byte } } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._q, .mov, .tmp3x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_, .unpcklbw, .tmp3x, .tmp3x, ._, ._ },
                        .{ ._, ._q, .mov, .tmp4x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_, .unpcklbw, .tmp4x, .tmp4x, ._, ._ },
                        .{ ._, .p_w, .mull, .tmp3x, .tmp4x, ._, ._ },
                        .{ ._, .p_, .@"and", .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, .p_b, .ackusw, .tmp3x, .tmp3x, ._, ._ },
                        .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .qword, .is = .byte } },
                        .{ .multiple_scalar_int = .{ .of = .qword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .pand_trunc_mem = .{ .from = .word, .to = .byte } } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._q, .mov, .tmp3x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_, .unpcklbw, .tmp3x, .tmp3x, ._, ._ },
                        .{ ._, ._q, .mov, .tmp4x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_, .unpcklbw, .tmp4x, .tmp4x, ._, ._ },
                        .{ ._, .p_w, .mull, .tmp3x, .tmp4x, ._, ._ },
                        .{ ._, .p_, .@"and", .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, .p_b, .ackusw, .tmp3x, .tmp3x, ._, ._ },
                        .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .reg = .al } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .i_, .mul, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .reg = .al } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .i_, .mul, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u8, .kind = .{ .pshufb_trunc_mem = .{ .of = .xword, .from = .word, .to = .byte } } },
                        .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_w, .movzxb, .tmp3y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .movzxb, .tmp4y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .mull, .tmp3y, .tmp3y, .tmp4y, ._ },
                        .{ ._, .vp_b, .shuf, .tmp3y, .tmp3y, .tmp2y, ._ },
                        .{ ._, .v_q, .perm, .tmp3y, .tmp3y, .ui(0b10_00_10_00), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u8, .kind = .{ .pshufb_trunc_mem = .{ .of = .xword, .from = .word, .to = .byte } } },
                        .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_w, .movzxb, .tmp3x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .movzxb, .tmp4x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .mull, .tmp3x, .tmp3x, .tmp4x, ._ },
                        .{ ._, .vp_b, .shuf, .tmp3x, .tmp3x, .tmp2x, ._ },
                        .{ ._, .v_q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u8, .kind = .{ .pshufb_trunc_mem = .{ .of = .xword, .from = .word, .to = .byte } } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_w, .movzxb, .tmp3x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_w, .movzxb, .tmp4x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_w, .mull, .tmp3x, .tmp4x, ._, ._ },
                        .{ ._, .p_b, .shuf, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .reg = .al } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mul, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .reg = .al } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mul, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_int = .{ .of = .xword, .is = .word } },
                        .{ .scalar_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .mull, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_int = .{ .of = .xword, .is = .word } },
                        .{ .scalar_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_w, .mull, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_int = .{ .of = .yword, .is = .word } },
                        .{ .scalar_int = .{ .of = .yword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .mull, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .yword, .is = .word } },
                        .{ .multiple_scalar_int = .{ .of = .yword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .mull, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .word } },
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .mull, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .word } },
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_w, .mull, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .i_, .mul, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .i_, .mul, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_int = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .mull, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_int = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_d, .mull, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_int = .{ .of = .yword, .is = .dword } },
                        .{ .scalar_int = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .mull, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .yword, .is = .dword } },
                        .{ .multiple_scalar_int = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_d, .mull, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } },
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_d, .mull, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } },
                        .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_d, .mull, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } },
                        .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .i_, .mul, .tmp1d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .i_, .mul, .tmp1q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, .adx, null },
                    .src_constraints = .{
                        .{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .isize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memia(.src1, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp4d, .sia(-8, .src0, .add_elem_size), ._, ._ },
                        .{ .@"1:", ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .leai(.tmp1q, .tmp4), ._, ._ },
                        .{ ._, ._z, .j, .@"3f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp6p, .leaad(.tmp4, .sub_src0_elem_size, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ .@"2:", ._x, .mul, .tmp9q, .tmp8q, .leai(.tmp2q, .tmp6), ._ },
                        .{ ._, ._x, .adc, .tmp8q, .tmp7q, ._, ._ },
                        .{ ._, ._, .mov, .leaiad(.tmp3q, .tmp6, .add_dst0_elem_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._rcxz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._x, .ado, .tmp9q, .leaia(.tmp3q, .tmp6, .add_dst0_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp9q, ._, ._ },
                        .{ ._, ._, .lea, .tmp6p, .lead(.tmp6, 8), ._, ._ },
                        .{ ._, ._mp, .j, .@"2b", ._, ._, ._ },
                        .{ .@"3:", ._, .mov, .leai(.tmp3q, .tmp4), .tmp5q, ._, ._ },
                        .{ .@"2:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp4d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, .slow_incdec, null },
                    .src_constraints = .{
                        .{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memiad(.src1, .tmp0, .add_unaligned_size, 8), ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp4d, .sia(-1, .src0, .add_elem_size_div_8), ._, ._ },
                        .{ .@"1:", ._, .lea, .tmp5p, .leaa(.tmp4, .sub_src0_elem_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp6q, .leasi(.tmp1q, .@"8", .tmp4), ._, ._ },
                        .{ ._, ._nz, .j, .@"3f", ._, ._, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp3q, .@"8", .tmp4), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"4f", ._, ._, ._ },
                        .{ .@"2:", ._, .adc, .tmp10q, .leasia(.tmp3q, .@"8", .tmp5, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ .@"3:", ._x, .mul, .tmp10q, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .leasia(.tmp3q, .@"8", .tmp5, .add_src0_elem_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"2b", ._, ._, ._ },
                        .{ .@"4:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp4d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, null, null },
                    .src_constraints = .{
                        .{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memiad(.src1, .tmp0, .add_unaligned_size, 8), ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp4d, .sia(-1, .src0, .add_elem_size_div_8), ._, ._ },
                        .{ .@"1:", ._, .lea, .tmp5p, .leaa(.tmp4, .sub_src0_elem_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp6q, .leasi(.tmp1q, .@"8", .tmp4), ._, ._ },
                        .{ ._, ._nz, .j, .@"3f", ._, ._, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp3q, .@"8", .tmp4), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"4f", ._, ._, ._ },
                        .{ .@"2:", ._, .adc, .tmp10q, .leasia(.tmp3q, .@"8", .tmp5, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ .@"3:", ._x, .mul, .tmp10q, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .leasia(.tmp3q, .@"8", .tmp5, .add_src0_elem_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"2b", ._, ._, ._ },
                        .{ .@"4:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp4d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memiad(.src1, .tmp0, .add_unaligned_size, 8), ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp4d, .sia(-1, .src0, .add_elem_size_div_8), ._, ._ },
                        .{ .@"1:", ._, .lea, .tmp5p, .leaa(.tmp4, .sub_src0_elem_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp6q, .leasi(.tmp1q, .@"8", .tmp4), ._, ._ },
                        .{ ._, ._nz, .j, .@"3f", ._, ._, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp3q, .@"8", .tmp4), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"4f", ._, ._, ._ },
                        .{ .@"2:", ._, .adc, .tmp10q, .leasia(.tmp3q, .@"8", .tmp5, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .mov, .tmp9q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mul, .leasi(.tmp2q, .@"8", .tmp5), ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .leasia(.tmp3q, .@"8", .tmp5, .add_src0_elem_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"2b", ._, ._, ._ },
                        .{ .@"4:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp4d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memiad(.src1, .tmp0, .add_unaligned_size, 8), ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp4d, .sia(-1, .src0, .add_elem_size_div_8), ._, ._ },
                        .{ .@"1:", ._, .lea, .tmp5p, .leaa(.tmp4, .sub_src0_elem_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp6q, .leasi(.tmp1q, .@"8", .tmp4), ._, ._ },
                        .{ ._, ._nz, .j, .@"3f", ._, ._, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp3q, .@"8", .tmp4), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"4f", ._, ._, ._ },
                        .{ .@"2:", ._, .adc, .tmp10q, .leasia(.tmp3q, .@"8", .tmp5, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .mov, .tmp9q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mul, .leasi(.tmp2q, .@"8", .tmp5), ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .leasia(.tmp3q, .@"8", .tmp5, .add_src0_elem_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"2b", ._, ._, ._ },
                        .{ .@"4:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp4d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f} {f}", .{
                        @tagName(air_tag),
                        ty.fmt(pt),
                        ops[0].tracking(cg),
                        ops[1].tracking(cg),
                    }),
                    else => |e| return e,
                };
                res[0].wrapInt(cg) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} wrap {f} {f}", .{
                        @tagName(air_tag),
                        cg.typeOf(bin_op.lhs).fmt(pt),
                        res[0].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
            },
            .mul_sat => |air_tag| {
                const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                var res: [1]Temp = undefined;
                cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{
                    .src_constraints = .{ .{ .exact_signed_int = 8 }, .{ .exact_signed_int = 8 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .al }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .al }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .al }, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .i_, .mul, .src1b, ._, ._, ._ },
                        .{ ._, ._nc, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .dst0b, .sa(.src0, .add_smax), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .al }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .al }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .al }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i8, .kind = .{ .rc = .gphi } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .i_, .mul, .src1b, ._, ._, ._ },
                        .{ ._, ._c, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp0b, .dst0h, ._, ._ },
                        .{ ._, ._e, .j, .@"0f", ._, ._, ._ },
                        .{ .@"1:", ._r, .sa, .dst0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .dst0b, .sa(.src0, .add_smax), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_unsigned_int = 8 }, .{ .exact_unsigned_int = 8 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .al }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .al }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .al }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u8, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mul, .src1b, ._, ._, ._ },
                        .{ ._, ._, .sbb, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .@"or", .dst0b, .tmp0b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .al }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .al }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .al }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mul, .src1b, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .cmp, .dst0w, .tmp0w, ._, ._ },
                        .{ ._, ._a, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .al }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .al }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .al }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mul, .src1b, ._, ._, ._ },
                        .{ ._, ._, .cmp, .dst0w, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .ua(.src0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 16 }, .{ .exact_signed_int = 16 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .ax }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .ax }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .ax }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .reg = .dx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, .i_, .mul, .src1w, ._, ._, ._ },
                        .{ ._, ._nc, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .dst0w, .sa(.src0, .add_smax), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_signed_int = 16 }, .{ .exact_signed_int = 16 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .ax }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .ax }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .ax }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .reg = .dx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, .i_, .mul, .src1w, ._, ._, ._ },
                        .{ ._, ._nc, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .ax }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .ax }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .ax }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .reg = .dx } },
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, .i_, .mul, .src1w, ._, ._, ._ },
                        .{ ._, ._c, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1w, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1w, .tmp0w, ._, ._ },
                        .{ ._, ._e, .j, .@"0f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .dst0w, .sa(.src0, .add_smax), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .ax }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .ax }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .ax }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .reg = .dx } },
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, .i_, .mul, .src1w, ._, ._, ._ },
                        .{ ._, ._c, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1w, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1w, .tmp0w, ._, ._ },
                        .{ ._, ._e, .j, .@"0f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smax), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_unsigned_int = 16 }, .{ .exact_unsigned_int = 16 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .ax }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .ax }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .ax }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .reg = .dx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .mul, .src1w, ._, ._, ._ },
                        .{ ._, ._, .sbb, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi, .cmov, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .ax }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .ax }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .ax }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .reg = .dx } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mul, .src1w, ._, ._, ._ },
                        .{ ._, ._, .andn, .tmp2d, .tmp1d, .dst0d, ._ },
                        .{ ._, ._, .@"or", .tmp2w, .tmp0w, ._, ._ },
                        .{ ._, ._nz, .cmov, .dst0d, .tmp1d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .fast_imm16, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .ax }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .ax }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .ax }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .reg = .dx } },
                        .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .mul, .src1w, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ },
                        .{ ._, ._, .@"and", .tmp1w, .sa(.src0, .add_2_smin), ._, ._ },
                        .{ ._, ._, .@"or", .tmp1w, .tmp0w, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._nz, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .ax }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .ax }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .ax }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .reg = .dx } },
                        .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .mul, .src1w, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ },
                        .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_2_smin), ._, ._ },
                        .{ ._, ._, .@"or", .tmp1w, .tmp0w, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._nz, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .ax }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .ax }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .ax }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .reg = .dx } },
                        .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .mul, .src1w, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ },
                        .{ ._, ._, .@"and", .tmp1w, .sa(.src0, .add_2_smin), ._, ._ },
                        .{ ._, ._, .@"or", .tmp1w, .tmp0w, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .ua(.src0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .ax }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .ax }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .ax }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .reg = .dx } },
                        .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .mul, .src1w, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ },
                        .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_2_smin), ._, ._ },
                        .{ ._, ._, .@"or", .tmp1w, .tmp0w, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .ua(.src0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_signed_int = 32 }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .eax }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .eax }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .eax }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i32, .kind = .{ .reg = .edx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .i_, .mul, .src1d, ._, ._, ._ },
                        .{ ._, ._nc, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .sa, .dst0d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smax), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .eax }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .eax }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .eax }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i32, .kind = .{ .reg = .edx } },
                        .{ .type = .i32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .i_, .mul, .src1d, ._, ._, ._ },
                        .{ ._, ._c, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1d, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._e, .j, .@"0f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .sa, .dst0d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smax), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .{ .exact_unsigned_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .eax }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .eax }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .eax }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .reg = .edx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mul, .src1d, ._, ._, ._ },
                        .{ ._, ._, .sbb, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi, .cmov, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .eax }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .eax }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .eax }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .reg = .edx } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp1d, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mul, .src1d, ._, ._, ._ },
                        .{ ._, ._, .andn, .tmp2d, .tmp1d, .dst0d, ._ },
                        .{ ._, ._, .@"or", .tmp2d, .tmp0d, ._, ._ },
                        .{ ._, ._nz, .cmov, .dst0d, .tmp1d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .eax }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .eax }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .eax }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .reg = .edx } },
                        .{ .type = .u32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mul, .src1d, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ },
                        .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_2_smin), ._, ._ },
                        .{ ._, ._, .@"or", .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._nz, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .eax }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .eax }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .eax }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .reg = .edx } },
                        .{ .type = .u32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mul, .src1d, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ },
                        .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_2_smin), ._, ._ },
                        .{ ._, ._, .@"or", .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .ua(.src0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 64 }, .{ .exact_signed_int = 64 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .rax }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .rax }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .rax }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .reg = .rdx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .i_, .mul, .src1q, ._, ._, ._ },
                        .{ ._, ._nc, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0q, .ua(.src0, .add_smax), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .xor, .dst0q, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .rax }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .rax }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .rax }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .reg = .rdx } },
                        .{ .type = .i64, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .i_, .mul, .src1q, ._, ._, ._ },
                        .{ ._, ._c, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .dst0q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._e, .j, .@"0f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .dst0q, .ua(.src0, .add_smax), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .xor, .dst0q, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .{ .exact_unsigned_int = 64 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .rax }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .rax }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .rax }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mul, .src1q, ._, ._, ._ },
                        .{ ._, ._, .sbb, .tmp0q, .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi, .cmov, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .rax }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .rax }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .rax }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mul, .src1q, ._, ._, ._ },
                        .{ ._, ._, .andn, .tmp2q, .tmp1q, .dst0q, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._nz, .cmov, .dst0q, .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .rax }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .rax }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .rax }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .u64, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mul, .src1q, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_2_smin), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1q, .dst0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._nz, .cmov, .dst0q, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .rax }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .rax }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .rax }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .u64, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mul, .src1q, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_2_smin), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1q, .dst0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0q, .ua(.src0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, .slow_incdec, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 128 } },
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 128 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp8q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._nz, .cmov, .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp9q, .tmp1q, ._, ._ },
                        .{ ._, ._, .not, .tmp9q, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._rd, .sh, .tmp9q, .tmp1q, .ui(1), ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp9q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 128 } },
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 128 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp8q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._nz, .cmov, .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp9q, .tmp1q, ._, ._ },
                        .{ ._, ._, .not, .tmp9q, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._rd, .sh, .tmp9q, .tmp1q, .ui(1), ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp9q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 128 } },
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 128 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp9q, .tmp1q, ._, ._ },
                        .{ ._, ._, .not, .tmp9q, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._rd, .sh, .tmp9q, .tmp1q, .ui(1), ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp9q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 128 } },
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 128 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp9q, .tmp1q, ._, ._ },
                        .{ ._, ._, .not, .tmp9q, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._rd, .sh, .tmp9q, .tmp1q, .ui(1), ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp9q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, .slow_incdec, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 64 } },
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp8q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._nz, .cmov, .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_size, -16), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._, .xor, .tmp2q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp9q, .tmp1q, ._, ._ },
                        .{ ._, ._, .not, .tmp9q, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._rd, .sh, .tmp9q, .tmp1q, .ui(1), ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp9q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 64 } },
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp8q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._nz, .cmov, .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_size, -16), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._, .xor, .tmp2q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp9q, .tmp1q, ._, ._ },
                        .{ ._, ._, .not, .tmp9q, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._rd, .sh, .tmp9q, .tmp1q, .ui(1), ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp9q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 64 } },
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_size, -16), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._, .xor, .tmp2q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp9q, .tmp1q, ._, ._ },
                        .{ ._, ._, .not, .tmp9q, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._rd, .sh, .tmp9q, .tmp1q, .ui(1), ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp9q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 64 } },
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_size, -16), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._, .xor, .tmp2q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp9q, .tmp1q, ._, ._ },
                        .{ ._, ._, .not, .tmp9q, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._rd, .sh, .tmp9q, .tmp1q, .ui(1), ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp9q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, .slow_incdec, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 1 } },
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 1 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp8q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._nz, .cmov, .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .xor, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp0q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._, .xor, .tmp2q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp9q, .tmp1q, ._, ._ },
                        .{ ._, ._, .not, .tmp9q, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 1 } },
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 1 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp8q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._nz, .cmov, .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .xor, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp0q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._, .xor, .tmp2q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp9q, .tmp1q, ._, ._ },
                        .{ ._, ._, .not, .tmp9q, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 1 } },
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 1 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .xor, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp0q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._, .xor, .tmp2q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp9q, .tmp1q, ._, ._ },
                        .{ ._, ._, .not, .tmp9q, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 1 } },
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 1 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .xor, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp0q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._, .xor, .tmp2q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp9q, .tmp1q, ._, ._ },
                        .{ ._, ._, .not, .tmp9q, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, .slow_incdec, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } },
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp8q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._nz, .cmov, .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .xor, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp0q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._, .xor, .tmp2q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp9q, .tmp1q, ._, ._ },
                        .{ ._, ._, .not, .tmp9q, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._rd, .sh, .tmp9q, .tmp1q, .uia(65, .dst0, .sub_bit_size_rem_64), ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp9q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } },
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp8q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._nz, .cmov, .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .xor, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp0q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._, .xor, .tmp2q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp9q, .tmp1q, ._, ._ },
                        .{ ._, ._, .not, .tmp9q, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._rd, .sh, .tmp9q, .tmp1q, .uia(65, .dst0, .sub_bit_size_rem_64), ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp9q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } },
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .xor, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp0q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._, .xor, .tmp2q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp9q, .tmp1q, ._, ._ },
                        .{ ._, ._, .not, .tmp9q, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._rd, .sh, .tmp9q, .tmp1q, .uia(65, .dst0, .sub_bit_size_rem_64), ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp9q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } },
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .xor, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp0q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._, .xor, .tmp2q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp9q, .tmp1q, ._, ._ },
                        .{ ._, ._, .not, .tmp9q, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._rd, .sh, .tmp9q, .tmp1q, .uia(65, .dst0, .sub_bit_size_rem_64), ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp9q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, .slow_incdec, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 65 } },
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 65 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp8q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._nz, .cmov, .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .xor, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp9q, .tmp1q, ._, ._ },
                        .{ ._, ._, .not, .tmp9q, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 65 } },
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 65 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp8q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._nz, .cmov, .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .xor, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp9q, .tmp1q, ._, ._ },
                        .{ ._, ._, .not, .tmp9q, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 65 } },
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 65 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .xor, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp9q, .tmp1q, ._, ._ },
                        .{ ._, ._, .not, .tmp9q, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 65 } },
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 65 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .xor, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp9q, .tmp1q, ._, ._ },
                        .{ ._, ._, .not, .tmp9q, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, .slow_incdec, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } },
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp8q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._nz, .cmov, .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .xor, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp9q, .tmp1q, ._, ._ },
                        .{ ._, ._, .not, .tmp9q, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._rd, .sh, .tmp9q, .tmp1q, .uia(65, .dst0, .sub_bit_size_rem_64), ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp9q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } },
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp8q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._nz, .cmov, .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .xor, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp9q, .tmp1q, ._, ._ },
                        .{ ._, ._, .not, .tmp9q, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._rd, .sh, .tmp9q, .tmp1q, .uia(65, .dst0, .sub_bit_size_rem_64), ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp9q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } },
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .xor, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp9q, .tmp1q, ._, ._ },
                        .{ ._, ._, .not, .tmp9q, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._rd, .sh, .tmp9q, .tmp1q, .uia(65, .dst0, .sub_bit_size_rem_64), ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp9q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } },
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .xor, .tmp2q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp9q, .tmp1q, ._, ._ },
                        .{ ._, ._, .not, .tmp9q, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._rd, .sh, .tmp9q, .tmp1q, .uia(65, .dst0, .sub_bit_size_rem_64), ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp9q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, .adx, null },
                    .src_constraints = .{
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 128 } },
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 128 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rax } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .isize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ .@"0:", ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._z, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp5p, .leaad(.tmp0, .sub_src0_size, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ .@"1:", ._x, .mul, .tmp8q, .tmp7q, .leai(.tmp1q, .tmp5), ._ },
                        .{ ._, ._x, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memiad(.dst0q, .tmp5, .add_size, -8), .tmp7q, ._, ._ },
                        .{ ._, ._rcxz, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._x, .ado, .tmp8q, .memia(.dst0q, .tmp5, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ ._, ._, .lea, .tmp5p, .lead(.tmp5, 8), ._, ._ },
                        .{ ._, ._mp, .j, .@"1b", ._, ._, ._ },
                        .{ .@"2:", ._, .mov, .memi(.dst0q, .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp4d, .tmp0d, ._, ._ },
                        .{ ._, ._x, .ado, .tmp8q, .tmp3q, ._, ._ },
                        .{ ._, ._x, .adc, .tmp8q, .tmp3q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp8q, .leaid(.tmp1q, .tmp4, 8), ._, ._ },
                        .{ .@"2:", ._, .sub, .tmp4d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .@"test", .tmp2q, .tmp2q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .si(-1), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .sa(.dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, .slow_incdec, null },
                    .src_constraints = .{
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 128 } },
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 128 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rax } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ },
                        .{ .@"2:", ._x, .mul, .tmp8q, .tmp7q, .leasi(.tmp1q, .@"8", .tmp3), ._ },
                        .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_size), .tmp7q, ._, ._ },
                        .{ ._, ._c, .in, .tmp3p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp8q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp5q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ },
                        .{ .@"2:", ._, .sub, .tmp3d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp5q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .@"test", .tmp2q, .tmp2q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .si(-1), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 128 } },
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 128 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rax } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ },
                        .{ .@"2:", ._x, .mul, .tmp8q, .tmp7q, .leasi(.tmp1q, .@"8", .tmp3), ._ },
                        .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_size), .tmp7q, ._, ._ },
                        .{ ._, ._c, .in, .tmp3p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp8q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp5q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp5q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .@"test", .tmp2q, .tmp2q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .si(-1), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 128 } },
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 128 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .usize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp7q, .tmp4q, ._, ._ },
                        .{ ._, ._, .mul, .leasi(.tmp1q, .@"8", .tmp3), ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_size), .tmp7q, ._, ._ },
                        .{ ._, ._c, .in, .tmp3p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp8q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp8q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ },
                        .{ .@"2:", ._, .sub, .tmp3d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .@"test", .tmp2q, .tmp2q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .si(-1), ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 128 } },
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 128 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .usize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp7q, .tmp4q, ._, ._ },
                        .{ ._, ._, .mul, .leasi(.tmp1q, .@"8", .tmp3), ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_size), .tmp7q, ._, ._ },
                        .{ ._, ._c, .in, .tmp3p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp8q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp8q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .@"test", .tmp2q, .tmp2q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .si(-1), ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, .adx, null },
                    .src_constraints = .{
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rax } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .isize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ .@"0:", ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._z, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp5p, .leaad(.tmp0, .sub_src0_size, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ .@"1:", ._x, .mul, .tmp8q, .tmp7q, .leai(.tmp1q, .tmp5), ._ },
                        .{ ._, ._x, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memiad(.dst0q, .tmp5, .add_size, -8), .tmp7q, ._, ._ },
                        .{ ._, ._rcxz, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._x, .ado, .tmp8q, .memia(.dst0q, .tmp5, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ ._, ._, .lea, .tmp5p, .lead(.tmp5, 8), ._, ._ },
                        .{ ._, ._mp, .j, .@"1b", ._, ._, ._ },
                        .{ .@"2:", ._, .mov, .memi(.dst0q, .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp4d, .tmp0d, ._, ._ },
                        .{ ._, ._x, .ado, .tmp8q, .tmp3q, ._, ._ },
                        .{ ._, ._x, .adc, .tmp8q, .tmp3q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp8q, .leaid(.tmp1q, .tmp4, 8), ._, ._ },
                        .{ .@"2:", ._, .sub, .tmp4d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .si(-1), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -8), .ui(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, .slow_incdec, null },
                    .src_constraints = .{
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rax } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ },
                        .{ .@"2:", ._x, .mul, .tmp8q, .tmp7q, .leasi(.tmp1q, .@"8", .tmp3), ._ },
                        .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_size), .tmp7q, ._, ._ },
                        .{ ._, ._c, .in, .tmp3p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp8q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp5q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ },
                        .{ .@"2:", ._, .sub, .tmp3d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp5q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .si(-1), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -8), .ui(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rax } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ },
                        .{ .@"2:", ._x, .mul, .tmp8q, .tmp7q, .leasi(.tmp1q, .@"8", .tmp3), ._ },
                        .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_size), .tmp7q, ._, ._ },
                        .{ ._, ._c, .in, .tmp3p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp8q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp5q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp5q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .si(-1), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -8), .ui(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .usize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp7q, .tmp4q, ._, ._ },
                        .{ ._, ._, .mul, .leasi(.tmp1q, .@"8", .tmp3), ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_size), .tmp7q, ._, ._ },
                        .{ ._, ._c, .in, .tmp3p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp8q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp8q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ },
                        .{ .@"2:", ._, .sub, .tmp3d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .si(-1), ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -8), .ui(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rdi } },
                        .{ .type = .usize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp7q, .tmp4q, ._, ._ },
                        .{ ._, ._, .mul, .leasi(.tmp1q, .@"8", .tmp3), ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_size), .tmp7q, ._, ._ },
                        .{ ._, ._c, .in, .tmp3p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp8q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp8q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .si(-1), ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -8), .ui(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, .adx, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .isize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ .@"0:", ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._z, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp5p, .leaad(.tmp0, .sub_src0_size, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ .@"1:", ._x, .mul, .tmp8q, .tmp7q, .leai(.tmp1q, .tmp5), ._ },
                        .{ ._, ._x, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memiad(.dst0q, .tmp5, .add_size, -8), .tmp7q, ._, ._ },
                        .{ ._, ._rcxz, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._x, .ado, .tmp8q, .memia(.dst0q, .tmp5, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ ._, ._, .lea, .tmp5p, .lead(.tmp5, 8), ._, ._ },
                        .{ ._, ._mp, .j, .@"1b", ._, ._, ._ },
                        .{ .@"2:", ._, .mov, .memi(.dst0q, .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp4d, .tmp0d, ._, ._ },
                        .{ ._, ._x, .ado, .tmp8q, .tmp3q, ._, ._ },
                        .{ ._, ._x, .adc, .tmp8q, .tmp3q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp8q, .leaid(.tmp1q, .tmp4, 8), ._, ._ },
                        .{ .@"2:", ._, .sub, .tmp4d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.dst0q, .add_size, -16), ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .bzhi, .tmp3q, .tmp1q, .tmp0q, ._ },
                        .{ ._, ._r, .sh, .tmp1q, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp1q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .si(-1), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .bzhi, .tmp3q, .tmp1q, .tmp0q, ._ },
                        .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -16), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .ui(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, .slow_incdec, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
                        .{ .type = .isize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ },
                        .{ .@"2:", ._x, .mul, .tmp8q, .tmp7q, .leasi(.tmp1q, .@"8", .tmp3), ._ },
                        .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_size), .tmp7q, ._, ._ },
                        .{ ._, ._c, .in, .tmp3p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp8q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp5q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ },
                        .{ .@"2:", ._, .sub, .tmp3d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp5q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.dst0q, .add_size, -16), ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .bzhi, .tmp3q, .tmp1q, .tmp0q, ._ },
                        .{ ._, ._r, .sh, .tmp1q, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp1q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .si(-1), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .bzhi, .tmp3q, .tmp1q, .tmp0q, ._ },
                        .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -16), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .ui(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
                        .{ .type = .isize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ },
                        .{ .@"2:", ._x, .mul, .tmp8q, .tmp7q, .leasi(.tmp1q, .@"8", .tmp3), ._ },
                        .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_size), .tmp7q, ._, ._ },
                        .{ ._, ._c, .in, .tmp3p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp8q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp5q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp5q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.dst0q, .add_size, -16), ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .bzhi, .tmp3q, .tmp1q, .tmp0q, ._ },
                        .{ ._, ._r, .sh, .tmp1q, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp1q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .si(-1), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .bzhi, .tmp3q, .tmp1q, .tmp0q, ._ },
                        .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -16), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .ui(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp7q, .tmp4q, ._, ._ },
                        .{ ._, ._, .mul, .leasi(.tmp1q, .@"8", .tmp3), ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_size), .tmp7q, ._, ._ },
                        .{ ._, ._c, .in, .tmp3p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp8q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp8q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ },
                        .{ .@"2:", ._, .sub, .tmp3d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.dst0q, .add_size, -16), ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp0q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp3q, .tmp1q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp1q, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp1q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .si(-1), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp0q, ._, ._ },
                        .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -16), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .ui(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp7q, .tmp4q, ._, ._ },
                        .{ ._, ._, .mul, .leasi(.tmp1q, .@"8", .tmp3), ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_size), .tmp7q, ._, ._ },
                        .{ ._, ._c, .in, .tmp3p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp8q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp8q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.dst0q, .add_size, -16), ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp0q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp3q, .tmp1q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp1q, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp1q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .si(-1), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp0q, ._, ._ },
                        .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -16), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .ui(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, .adx, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .isize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ .@"0:", ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._z, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp5p, .leaad(.tmp0, .sub_src0_size, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ .@"1:", ._x, .mul, .tmp8q, .tmp7q, .leai(.tmp1q, .tmp5), ._ },
                        .{ ._, ._x, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memiad(.dst0q, .tmp5, .add_size, -8), .tmp7q, ._, ._ },
                        .{ ._, ._rcxz, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._x, .ado, .tmp8q, .memia(.dst0q, .tmp5, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ ._, ._, .lea, .tmp5p, .lead(.tmp5, 8), ._, ._ },
                        .{ ._, ._mp, .j, .@"1b", ._, ._, ._ },
                        .{ .@"2:", ._, .mov, .memi(.dst0q, .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp4d, .tmp0d, ._, ._ },
                        .{ ._, ._x, .ado, .tmp8q, .tmp3q, ._, ._ },
                        .{ ._, ._x, .adc, .tmp8q, .tmp3q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp8q, .leaid(.tmp1q, .tmp4, 8), ._, ._ },
                        .{ .@"2:", ._, .sub, .tmp4d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .bzhi, .tmp3q, .tmp1q, .tmp0q, ._ },
                        .{ ._, ._r, .sh, .tmp1q, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp1q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .si(-1), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .bzhi, .tmp3q, .tmp1q, .tmp0q, ._ },
                        .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -8), .tmp3q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, .slow_incdec, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
                        .{ .type = .isize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ },
                        .{ .@"2:", ._x, .mul, .tmp8q, .tmp7q, .leasi(.tmp1q, .@"8", .tmp3), ._ },
                        .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_size), .tmp7q, ._, ._ },
                        .{ ._, ._c, .in, .tmp3p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp8q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp5q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ },
                        .{ .@"2:", ._, .sub, .tmp3d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp5q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .bzhi, .tmp3q, .tmp1q, .tmp0q, ._ },
                        .{ ._, ._r, .sh, .tmp1q, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp1q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .si(-1), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .bzhi, .tmp3q, .tmp1q, .tmp0q, ._ },
                        .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -8), .tmp3q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
                        .{ .type = .isize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ },
                        .{ .@"2:", ._x, .mul, .tmp8q, .tmp7q, .leasi(.tmp1q, .@"8", .tmp3), ._ },
                        .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_size), .tmp7q, ._, ._ },
                        .{ ._, ._c, .in, .tmp3p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp8q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp5q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp5q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .bzhi, .tmp3q, .tmp1q, .tmp0q, ._ },
                        .{ ._, ._r, .sh, .tmp1q, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp1q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .si(-1), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .bzhi, .tmp3q, .tmp1q, .tmp0q, ._ },
                        .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -8), .tmp3q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp7q, .tmp4q, ._, ._ },
                        .{ ._, ._, .mul, .leasi(.tmp1q, .@"8", .tmp3), ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_size), .tmp7q, ._, ._ },
                        .{ ._, ._c, .in, .tmp3p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp8q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp8q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ },
                        .{ .@"2:", ._, .sub, .tmp3d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp0q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp3q, .tmp1q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp1q, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp1q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .si(-1), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp0q, ._, ._ },
                        .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -8), .tmp3q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp7q, .tmp4q, ._, ._ },
                        .{ ._, ._, .mul, .leasi(.tmp1q, .@"8", .tmp3), ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_size), .tmp7q, ._, ._ },
                        .{ ._, ._c, .in, .tmp3p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp8q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp8q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp0q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp3q, .tmp1q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp1q, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp1q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .si(-1), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp0q, ._, ._ },
                        .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -8), .tmp3q, ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f} {f}", .{
                        @tagName(air_tag),
                        cg.typeOf(bin_op.lhs).fmt(pt),
                        ops[0].tracking(cg),
                        ops[1].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
            },
            .div_float, .div_float_optimized, .div_exact, .div_exact_optimized => |air_tag| {
                const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                const ty = cg.typeOf(bin_op.lhs);
                var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                var res: [1]Temp = undefined;
                (if (cg.floatBits(ty.scalarType(zcu))) |_| cg.select(&res, &.{ty}, &ops, comptime &.{ .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
                        .{ ._, .v_ss, .div, .dst0x, .dst0x, .tmp0d, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .word } },
                        .{ .scalar_float = .{ .of = .qword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_4_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
                        .{ ._, .v_ps, .div, .dst0x, .dst0x, .tmp0x, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .word } },
                        .{ .scalar_float = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ },
                        .{ ._, .v_ps, .div, .dst0y, .dst0y, .tmp0y, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_ps, .div, .tmp1y, .tmp1y, .tmp2y, ._ },
                        .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ },
                        .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
                        .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0) },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                        .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                        .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .tmp4d, .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ss, .div, .dst0x, .src0x, .src1d, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._ss, .div, .dst0x, .src1d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .div, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._ps, .div, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .yword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .div, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_ps, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_ps, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._ps, .div, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_sd, .div, .dst0x, .src0x, .src1q, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._sd, .div, .dst0x, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f64, .kind = .{ .reg = .st6 } },
                        .{ .type = .f64, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0q, ._, ._, ._ },
                        .{ ._, .f_, .div, .src1q, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_pd, .div, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._pd, .div, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .yword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .yword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_pd, .div, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_pd, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_pd, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._pd, .div, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .reg = .st6 } },
                        .{ .type = .f64, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, .f_, .div, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, .f_p, .st, .memia(.dst0q, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
                        .{ ._, .f_p, .div, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .msvc,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
                        .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp3d, .memd(.tmp2b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_00_11), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp2b, 1), .tmp3b, ._, ._ },
                        .{ ._, .f_p, .div, ._, ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .f_, .divr, .tmp0t, .src1t, ._, ._ },
                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .msvc,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_00_11), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
                        .{ ._, .f_, .divr, .tmp0t, .src1t, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .to_x87, .none } },
                        .{ .src = .{ .to_x87, .to_x87, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .f_, .div, .tmp0t, .src1t, ._, ._ },
                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .msvc,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .to_x87, .none } },
                        .{ .src = .{ .to_x87, .to_x87, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_00_11), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
                        .{ ._, .f_, .div, .tmp0t, .src1t, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, .f_p, .div, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .msvc,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .fn_cw, .st, .tmp0w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp1d, .memd(.tmp0b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp0b, 1), .ui(0b000_0_00_11), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp0b, 1), .tmp1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp1, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, .f_, .ld, .memia(.src1t, .tmp1, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, .f_p, .div, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .memia(.dst0t, .tmp1, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp2x, .memi(.src1x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .memi(.src1x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._ps, .mova, .tmp2x, .memi(.src1x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memi(.src1, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp4x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memi(.src1, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp4x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memi(.src1, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp4x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                } }) else err: {
                    assert(air_tag == .div_exact);
                    res[0] = ops[0].divTruncInts(&ops[1], cg) catch |err| break :err err;
                }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f} {f}", .{
                        @tagName(air_tag),
                        ty.fmt(pt),
                        ops[0].tracking(cg),
                        ops[1].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
            },
            .div_trunc => |air_tag| {
                const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                const ty = cg.typeOf(bin_op.lhs);
                var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                var res: [1]Temp = undefined;
                (if (cg.floatBits(ty.scalarType(zcu))) |_| cg.select(&res, &.{ty}, &ops, comptime &.{ .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
                        .{ ._, .v_ss, .div, .dst0x, .dst0x, .tmp0d, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        .{ ._, .v_ps, .cvtph2, .dst0x, .dst0q, ._, ._ },
                        .{ ._, .v_ss, .round, .dst0x, .dst0x, .dst0d, .rm(.{ .direction = .zero, .precision = .inexact }) },
                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__trunch" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .word } },
                        .{ .scalar_float = .{ .of = .qword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_4_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
                        .{ ._, .v_ps, .div, .dst0x, .dst0x, .tmp0x, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        .{ ._, .v_ps, .cvtph2, .dst0x, .dst0q, ._, ._ },
                        .{ ._, .v_ps, .round, .dst0x, .dst0x, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .word } },
                        .{ .scalar_float = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ },
                        .{ ._, .v_ps, .div, .dst0y, .dst0y, .tmp0y, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
                        .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                        .{ ._, .v_ps, .round, .dst0y, .dst0y, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_ps, .div, .tmp1y, .tmp1y, .tmp2y, ._ },
                        .{ ._, .v_, .cvtps2ph, .tmp1x, .tmp1y, .rm(.{}), ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp1y, .tmp1x, ._, ._ },
                        .{ ._, .v_ps, .round, .tmp1y, .tmp1y, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
                        .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__trunch" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ },
                        .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
                        .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0) },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__trunch" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                        .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__trunch" } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                        .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .tmp5d, .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp5w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__trunch" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ss, .div, .dst0x, .src0x, .src1d, ._ },
                        .{ ._, .v_ss, .round, .dst0x, .dst0x, .dst0d, .rm(.{ .direction = .zero, .precision = .inexact }) },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._ss, .div, .dst0x, .src1d, ._, ._ },
                        .{ ._, ._ss, .round, .dst0x, .dst0d, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "truncf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._ss, .div, .dst0x, .src1d, ._, ._ },
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .div, .dst0x, .src0x, .src1x, ._ },
                        .{ ._, .v_ps, .round, .dst0x, .dst0x, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._ps, .div, .dst0x, .src1x, ._, ._ },
                        .{ ._, ._ps, .round, .dst0x, .dst0x, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "truncf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._ss, .div, .tmp1x, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .yword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .div, .dst0y, .src0y, .src1y, ._ },
                        .{ ._, .v_ps, .round, .dst0y, .dst0y, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_ps, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_ps, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_ps, .round, .tmp1y, .tmp1y, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
                        .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._ps, .div, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._ps, .round, .tmp1x, .tmp1x, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
                        .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_sd, .div, .dst0x, .src0x, .src1q, ._ },
                        .{ ._, .v_sd, .round, .dst0x, .dst0x, .dst0q, .rm(.{ .direction = .zero, .precision = .inexact }) },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._sd, .div, .dst0x, .src1q, ._, ._ },
                        .{ ._, ._sd, .round, .dst0x, .dst0q, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "trunc" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._sd, .div, .dst0x, .src1q, ._, ._ },
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__divdf3" } },
                        .{ .type = .usize, .kind = .{ .extern_func = "trunc" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_pd, .div, .dst0x, .src0x, .src1x, ._ },
                        .{ ._, .v_pd, .round, .dst0x, .dst0x, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._pd, .div, .dst0x, .src1x, ._, ._ },
                        .{ ._, ._pd, .round, .dst0x, .dst0x, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .yword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .yword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_pd, .div, .dst0y, .src0y, .src1y, ._ },
                        .{ ._, .v_pd, .round, .dst0y, .dst0y, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_pd, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_pd, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_pd, .round, .tmp1y, .tmp1y, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
                        .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._pd, .div, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._pd, .round, .tmp1x, .tmp1x, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
                        .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "trunc" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._sd, .div, .tmp1x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__divdf3" } },
                        .{ .type = .usize, .kind = .{ .extern_func = "trunc" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._ps, .xor, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._ps, .movl, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__truncx" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .reg = .st0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
                        .{ ._, .f_p, .div, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .mem(.tmp2t), ._, ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_cc_abi = .win64,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__truncx" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ ._, .f_p, .div, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .lea(.tmp2t), ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3p, .tmp2p, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .msvc,
                    .required_cc_abi = .win64,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__truncx" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
                        .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp3d, .memd(.tmp2b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_00_11), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp2b, 1), .tmp3b, ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .mem(.dst0), ._, ._ },
                        .{ ._, .f_p, .div, ._, ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
                        .{ ._, .f_p, .st, .lea(.tmp3t), ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp4p, .tmp3p, ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__truncx" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, .f_p, .div, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .mem(.tmp3t), ._, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_cc_abi = .win64,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__truncx" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, .f_p, .div, ._, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .f_p, .st, .lea(.tmp3t), ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp4p, .tmp3p, ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .msvc,
                    .required_cc_abi = .win64,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__truncx" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, .fn_cw, .st, .tmp0w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp1d, .memd(.tmp0b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp0b, 1), .ui(0b000_0_00_11), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp0b, 1), .tmp1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp1, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, .f_, .ld, .memia(.src1t, .tmp1, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, .f_p, .div, ._, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp4p, .memia(.dst0, .tmp1, .add_unaligned_size), ._, ._ },
                        .{ ._, .f_p, .st, .lea(.tmp4t), ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5p, .tmp4p, ._, ._ },
                        .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
                        .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                        .{ .type = .usize, .kind = .{ .extern_func = "truncq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                        .{ .type = .f128, .kind = .mem },
                        .{ .type = .usize, .kind = .{ .extern_func = "truncq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                        .{ ._, .v_dqa, .mov, .lea(.tmp0x), .dst0x, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                        .{ .type = .f128, .kind = .mem },
                        .{ .type = .usize, .kind = .{ .extern_func = "truncq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                        .{ ._, ._dqa, .mov, .lea(.tmp0x), .dst0x, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                        .{ .type = .f128, .kind = .mem },
                        .{ .type = .usize, .kind = .{ .extern_func = "truncq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                        .{ ._, ._ps, .mova, .lea(.tmp0x), .dst0x, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                        .{ .type = .usize, .kind = .{ .extern_func = "truncq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp2x, .memi(.src1x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                        .{ .type = .usize, .kind = .{ .extern_func = "truncq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .memi(.src1x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                        .{ .type = .usize, .kind = .{ .extern_func = "truncq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._ps, .mova, .tmp2x, .memi(.src1x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                        .{ .type = .f128, .kind = .mem },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "truncq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memi(.src1x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp4), ._, ._ },
                        .{ ._, .v_dqa, .mov, .lea(.tmp1x), .tmp5x, ._, ._ },
                        .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp5x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                        .{ .type = .f128, .kind = .mem },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "truncq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memi(.src1x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp4), ._, ._ },
                        .{ ._, ._dqa, .mov, .lea(.tmp1x), .tmp5x, ._, ._ },
                        .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp5x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                        .{ .type = .f128, .kind = .mem },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "truncq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memi(.src1x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp4), ._, ._ },
                        .{ ._, ._ps, .mova, .lea(.tmp1x), .tmp5x, ._, ._ },
                        .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp5x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                } }) else err: {
                    res[0] = ops[0].divTruncInts(&ops[1], cg) catch |err| break :err err;
                }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f} {f}", .{
                        @tagName(air_tag),
                        ty.fmt(pt),
                        ops[0].tracking(cg),
                        ops[1].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
            },
            .div_trunc_optimized, .div_floor_optimized => |air_tag| {
                const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                var res: [1]Temp = undefined;
                cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, switch (@as(bits.RoundMode.Direction, switch (air_tag) {
                    else => unreachable,
                    .div_trunc_optimized => .zero,
                    .div_floor_optimized => .down,
                })) {
                    else => unreachable,
                    inline .zero, .down => |direction| comptime &.{ .{
                        .required_features = .{ .f16c, null, null, null },
                        .src_constraints = .{
                            .{ .scalar_float = .{ .of = .word, .is = .word } },
                            .{ .scalar_float = .{ .of = .word, .is = .word } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .to_sse, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
                            .{ ._, .v_ss, .div, .dst0x, .dst0x, .tmp0d, ._ },
                            .{ ._, .v_ss, .round, .dst0x, .dst0x, .dst0d, .rm(.{ .direction = direction, .precision = .inexact }) },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .src_constraints = .{
                            .{ .scalar_float = .{ .of = .word, .is = .word } },
                            .{ .scalar_float = .{ .of = .word, .is = .word } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{
                                .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                                .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                                .none,
                            } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .zero => "__trunch",
                                .down => "__floorh",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                            .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .src_constraints = .{
                            .{ .scalar_float = .{ .of = .qword, .is = .word } },
                            .{ .scalar_float = .{ .of = .qword, .is = .word } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .mem, .mem, .none } },
                            .{ .src = .{ .to_sse, .mem, .none } },
                            .{ .src = .{ .mem, .to_sse, .none } },
                            .{ .src = .{ .to_sse, .to_sse, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
                            .{ ._, .v_ps, .div, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .src_constraints = .{
                            .{ .scalar_float = .{ .of = .xword, .is = .word } },
                            .{ .scalar_float = .{ .of = .xword, .is = .word } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .mem, .mem, .none } },
                            .{ .src = .{ .to_sse, .mem, .none } },
                            .{ .src = .{ .mem, .to_sse, .none } },
                            .{ .src = .{ .to_sse, .to_sse, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ },
                            .{ ._, .v_ps, .div, .dst0y, .dst0y, .tmp0y, ._ },
                            .{ ._, .v_ps, .round, .dst0y, .dst0y, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .src_constraints = .{
                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .to_mem, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                            .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_ps, .div, .tmp1y, .tmp1y, .tmp2y, ._ },
                            .{ ._, .v_ps, .round, .tmp1y, .tmp1y, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
                            .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ },
                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .src_constraints = .{
                            .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                            .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .to_mem, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .zero => "__trunch",
                                .down => "__floorh",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                            .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ },
                            .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
                            .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0) },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                            .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
                            .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .src_constraints = .{
                            .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                            .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .to_mem, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .zero => "__trunch",
                                .down => "__floorh",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                            .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                            .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                            .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
                            .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .src_constraints = .{
                            .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                            .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .to_mem, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .zero => "__trunch",
                                .down => "__floorh",
                            } } },
                            .{ .type = .f16, .kind = .{ .reg = .ax } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                            .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                            .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                            .{ ._, .p_w, .extr, .tmp5d, .tmp1x, .ui(0), ._ },
                            .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp5w, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .src_constraints = .{
                            .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                            .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .to_mem, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f16, .kind = .{ .reg = .ax } },
                            .{ .type = .f32, .kind = .mem },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .zero => "__trunch",
                                .down => "__floorh",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                            .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                            .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
                            .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                            .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ },
                            .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                            .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
                            .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ },
                            .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ },
                            .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .src_constraints = .{
                            .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                            .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .mem, .none } },
                            .{ .src = .{ .to_sse, .to_sse, .none } },
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ss, .div, .dst0x, .src0x, .src1d, ._ },
                            .{ ._, .v_ss, .round, .dst0x, .dst0x, .dst0d, .rm(.{ .direction = direction, .precision = .inexact }) },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .src_constraints = .{
                            .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                            .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .mem, .none } },
                            .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ss, .div, .dst0x, .src1d, ._, ._ },
                            .{ ._, ._ss, .round, .dst0x, .dst0d, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .src_constraints = .{
                            .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                            .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .to_mem, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .zero => "truncf",
                                .down => "floorf",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._ss, .div, .dst0x, .src1d, ._, ._ },
                            .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .src_constraints = .{
                            .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                            .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .mem, .none } },
                            .{ .src = .{ .to_sse, .to_sse, .none } },
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .div, .dst0x, .src0x, .src1x, ._ },
                            .{ ._, .v_ps, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .src_constraints = .{
                            .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                            .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .mem, .none } },
                            .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .div, .dst0x, .src1x, ._, ._ },
                            .{ ._, ._ps, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .src_constraints = .{
                            .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
                            .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .to_mem, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .zero => "truncf",
                                .down => "floorf",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                            .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._ss, .div, .tmp1x, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .src_constraints = .{
                            .{ .scalar_float = .{ .of = .yword, .is = .dword } },
                            .{ .scalar_float = .{ .of = .yword, .is = .dword } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .mem, .none } },
                            .{ .src = .{ .to_sse, .to_sse, .none } },
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .div, .dst0y, .src0y, .src1y, ._ },
                            .{ ._, .v_ps, .round, .dst0y, .dst0y, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .src_constraints = .{
                            .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
                            .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .to_mem, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                            .{ .@"0:", .v_ps, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_ps, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                            .{ ._, .v_ps, .round, .tmp1y, .tmp1y, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
                            .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .src_constraints = .{
                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .to_mem, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                            .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._ps, .div, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._ps, .round, .tmp1x, .tmp1x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
                            .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .src_constraints = .{
                            .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                            .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .mem, .none } },
                            .{ .src = .{ .to_sse, .to_sse, .none } },
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_sd, .div, .dst0x, .src0x, .src1q, ._ },
                            .{ ._, .v_sd, .round, .dst0x, .dst0x, .dst0q, .rm(.{ .direction = direction, .precision = .inexact }) },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .src_constraints = .{
                            .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                            .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .mem, .none } },
                            .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._sd, .div, .dst0x, .src1q, ._, ._ },
                            .{ ._, ._sd, .round, .dst0x, .dst0q, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .src_constraints = .{
                            .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                            .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .to_mem, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .zero => "trunc",
                                .down => "floor",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._sd, .div, .dst0x, .src1q, ._, ._ },
                            .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .src_constraints = .{
                            .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                            .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{
                                .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                                .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                                .none,
                            } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .extern_func = "__divdf3" } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .zero => "trunc",
                                .down => "floor",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                            .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .src_constraints = .{
                            .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                            .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .mem, .none } },
                            .{ .src = .{ .to_sse, .to_sse, .none } },
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_pd, .div, .dst0x, .src0x, .src1x, ._ },
                            .{ ._, .v_pd, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .src_constraints = .{
                            .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                            .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .mem, .none } },
                            .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._pd, .div, .dst0x, .src1x, ._, ._ },
                            .{ ._, ._pd, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .src_constraints = .{
                            .{ .scalar_float = .{ .of = .yword, .is = .qword } },
                            .{ .scalar_float = .{ .of = .yword, .is = .qword } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .mem, .none } },
                            .{ .src = .{ .to_sse, .to_sse, .none } },
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_pd, .div, .dst0y, .src0y, .src1y, ._ },
                            .{ ._, .v_pd, .round, .dst0y, .dst0y, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .src_constraints = .{
                            .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
                            .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .to_mem, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                            .{ .@"0:", .v_pd, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_pd, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                            .{ ._, .v_pd, .round, .tmp1y, .tmp1y, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
                            .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .src_constraints = .{
                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .to_mem, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                            .{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._pd, .div, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._pd, .round, .tmp1x, .tmp1x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
                            .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .src_constraints = .{
                            .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                            .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .to_mem, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .zero => "trunc",
                                .down => "floor",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                            .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._sd, .div, .tmp1x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .src_constraints = .{
                            .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                            .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .to_mem, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__divdf3" } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .zero => "trunc",
                                .down => "floor",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                            .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .xor, .tmp2x, .tmp2x, ._, ._ },
                            .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._ps, .movl, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                            .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_abi = .gnu,
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .x87, null, null, null },
                        .src_constraints = .{
                            .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                            .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .to_mem, .none } },
                        },
                        .call_frame = .{ .size = 16, .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .f80, .kind = .{ .reg = .st6 } },
                            .{ .type = .f80, .kind = .{ .reg = .st7 } },
                            .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .zero => "__truncx",
                                .down => "__floorx",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .reg = .st0 }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                            .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
                            .{ ._, .f_p, .div, ._, ._, ._, ._ },
                            .{ ._, .f_p, .st, .mem(.tmp2t), ._, ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        } },
                    }, .{
                        .required_abi = .gnu,
                        .required_cc_abi = .win64,
                        .required_features = .{ .x87, null, null, null },
                        .src_constraints = .{
                            .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                            .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .to_mem, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .f80, .kind = .{ .reg = .st6 } },
                            .{ .type = .f80, .kind = .{ .reg = .st7 } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .zero => "__truncx",
                                .down => "__floorx",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                            .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                            .{ ._, .f_p, .div, ._, ._, ._, ._ },
                            .{ ._, .f_p, .st, .lea(.tmp2t), ._, ._, ._ },
                            .{ ._, ._, .mov, .tmp3p, .tmp2p, ._, ._ },
                            .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        } },
                    }, .{
                        .required_abi = .msvc,
                        .required_cc_abi = .win64,
                        .required_features = .{ .x87, null, null, null },
                        .src_constraints = .{
                            .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                            .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .to_mem, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .f80, .kind = .{ .reg = .st6 } },
                            .{ .type = .f80, .kind = .{ .reg = .st7 } },
                            .{ .type = .u16, .kind = .mem },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .zero => "__truncx",
                                .down => "__floorx",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                            .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
                            .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ },
                            .{ ._, ._, .movzx, .tmp3d, .memd(.tmp2b, 1), ._, ._ },
                            .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_00_11), ._, ._ },
                            .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
                            .{ ._, ._, .mov, .memd(.tmp2b, 1), .tmp3b, ._, ._ },
                            .{ ._, ._, .lea, .tmp3p, .mem(.dst0), ._, ._ },
                            .{ ._, .f_p, .div, ._, ._, ._, ._ },
                            .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
                            .{ ._, .f_p, .st, .lea(.tmp3t), ._, ._, ._ },
                            .{ ._, ._, .mov, .tmp4p, .tmp3p, ._, ._ },
                            .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        } },
                    }, .{
                        .required_abi = .gnu,
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .x87, null, null, null },
                        .src_constraints = .{
                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .to_mem, .none } },
                        },
                        .call_frame = .{ .size = 16, .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f80, .kind = .{ .reg = .st6 } },
                            .{ .type = .f80, .kind = .{ .reg = .st7 } },
                            .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .zero => "__truncx",
                                .down => "__floorx",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                            .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                            .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                            .{ ._, .f_p, .div, ._, ._, ._, ._ },
                            .{ ._, .f_p, .st, .mem(.tmp3t), ._, ._, ._ },
                            .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                            .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                            .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_abi = .gnu,
                        .required_cc_abi = .win64,
                        .required_features = .{ .x87, null, null, null },
                        .src_constraints = .{
                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .to_mem, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f80, .kind = .{ .reg = .st6 } },
                            .{ .type = .f80, .kind = .{ .reg = .st7 } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .zero => "__truncx",
                                .down => "__floorx",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                            .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                            .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                            .{ ._, .f_p, .div, ._, ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp3p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, .f_p, .st, .lea(.tmp3t), ._, ._, ._ },
                            .{ ._, ._, .mov, .tmp4p, .tmp3p, ._, ._ },
                            .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_abi = .msvc,
                        .required_cc_abi = .win64,
                        .required_features = .{ .x87, null, null, null },
                        .src_constraints = .{
                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .to_mem, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u16, .kind = .mem },
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f80, .kind = .{ .reg = .st6 } },
                            .{ .type = .f80, .kind = .{ .reg = .st7 } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .zero => "__truncx",
                                .down => "__floorx",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, .fn_cw, .st, .tmp0w, ._, ._, ._ },
                            .{ ._, ._, .movzx, .tmp1d, .memd(.tmp0b, 1), ._, ._ },
                            .{ ._, ._, .@"or", .memd(.tmp0b, 1), .ui(0b000_0_00_11), ._, ._ },
                            .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ },
                            .{ ._, ._, .mov, .memd(.tmp0b, 1), .tmp1b, ._, ._ },
                            .{ ._, ._, .mov, .tmp1p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                            .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp1, .add_unaligned_size), ._, ._, ._ },
                            .{ ._, .f_, .ld, .memia(.src1t, .tmp1, .add_unaligned_size), ._, ._, ._ },
                            .{ ._, .f_p, .div, ._, ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp4p, .memia(.dst0, .tmp1, .add_unaligned_size), ._, ._ },
                            .{ ._, .f_p, .st, .lea(.tmp4t), ._, ._, ._ },
                            .{ ._, ._, .mov, .tmp5p, .tmp4p, ._, ._ },
                            .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
                            .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .sse, null, null, null },
                        .src_constraints = .{
                            .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                            .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{
                                .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                                .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                                .none,
                            } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .zero => "truncq",
                                .down => "floorq",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                            .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .required_features = .{ .avx, null, null, null },
                        .src_constraints = .{
                            .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                            .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .to_mem, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                            .{ .type = .f128, .kind = .mem },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .zero => "truncq",
                                .down => "floorq",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                            .{ ._, .v_dqa, .mov, .lea(.tmp0x), .dst0x, ._, ._ },
                            .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .required_features = .{ .sse2, null, null, null },
                        .src_constraints = .{
                            .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                            .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .to_mem, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                            .{ .type = .f128, .kind = .mem },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .zero => "truncq",
                                .down => "floorq",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                            .{ ._, ._dqa, .mov, .lea(.tmp0x), .dst0x, ._, ._ },
                            .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .required_features = .{ .sse, null, null, null },
                        .src_constraints = .{
                            .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                            .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .to_mem, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                            .{ .type = .f128, .kind = .mem },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .zero => "truncq",
                                .down => "floorq",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                            .{ ._, ._ps, .mova, .lea(.tmp0x), .dst0x, ._, ._ },
                            .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .avx, null, null, null },
                        .src_constraints = .{
                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .to_mem, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .zero => "truncq",
                                .down => "floorq",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp2x, .memi(.src1x, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                            .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .sse2, null, null, null },
                        .src_constraints = .{
                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .to_mem, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .zero => "truncq",
                                .down => "floorq",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .memi(.src1x, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                            .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .sse, null, null, null },
                        .src_constraints = .{
                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .to_mem, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .zero => "truncq",
                                .down => "floorq",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._ps, .mova, .tmp2x, .memi(.src1x, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                            .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .required_features = .{ .avx, null, null, null },
                        .src_constraints = .{
                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .to_mem, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                            .{ .type = .f128, .kind = .mem },
                            .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .zero => "truncq",
                                .down => "floorq",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .lea, .tmp2p, .memi(.src1x, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.tmp4), ._, ._ },
                            .{ ._, .v_dqa, .mov, .lea(.tmp1x), .tmp5x, ._, ._ },
                            .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
                            .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp5x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .required_features = .{ .sse2, null, null, null },
                        .src_constraints = .{
                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .to_mem, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                            .{ .type = .f128, .kind = .mem },
                            .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .zero => "truncq",
                                .down => "floorq",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .lea, .tmp2p, .memi(.src1x, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.tmp4), ._, ._ },
                            .{ ._, ._dqa, .mov, .lea(.tmp1x), .tmp5x, ._, ._ },
                            .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
                            .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp5x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .required_features = .{ .sse, null, null, null },
                        .src_constraints = .{
                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .to_mem, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                            .{ .type = .f128, .kind = .mem },
                            .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .zero => "truncq",
                                .down => "floorq",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .lea, .tmp2p, .memi(.src1x, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.tmp4), ._, ._ },
                            .{ ._, ._ps, .mova, .lea(.tmp1x), .tmp5x, ._, ._ },
                            .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
                            .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp5x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        } },
                    } },
                }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f} {f}", .{
                        @tagName(air_tag),
                        cg.typeOf(bin_op.lhs).fmt(pt),
                        ops[0].tracking(cg),
                        ops[1].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
            },
            .div_floor => |air_tag| {
                const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                const ty = cg.typeOf(bin_op.lhs);
                var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                var res: [1]Temp = undefined;
                (if (cg.intInfo(ty)) |int_info| err: switch (int_info.signedness) {
                    .signed => cg.select(&res, &.{ty}, &ops, comptime &.{ .{
                        .src_constraints = .{ .{ .exact_signed_int = 1 }, .{ .exact_signed_int = 1 }, .any },
                        .patterns = &.{
                            .{ .src = .{ .any, .any, .none } },
                        },
                        .dst_temps = .{ .{ .imm = 0 }, .unused },
                        .each = .{ .once = &.{} },
                    }, .{
                        .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .to_mut_gphi, .none } },
                            .{ .src = .{ .to_gpr, .to_mut_gphi, .none } },
                        },
                        .dst_temps = .{ .{ .reg = .al }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .movsx, .dst0d, .src0b, ._, ._ },
                            .{ ._, .i_, .div, .src1b, ._, ._, ._ },
                            .{ ._, ._, .@"and", .src1b, .sa(.src0, .add_smin), ._, ._ },
                            .{ ._, ._, .xor, .src1b, .dst0h, ._, ._ },
                            .{ ._, ._, .cmp, .src1b, .sia(1, .src0, .add_smin), ._, ._ },
                            .{ ._, ._, .adc, .dst0b, .si(-1), ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .fast_imm16, null, null, null },
                        .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                        .patterns = &.{
                            .{ .src = .{ .{ .to_reg = .ax }, .to_mut_gpr, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .i16, .kind = .{ .reg = .dx } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .cwd, ._, ._, ._, ._ },
                            .{ ._, .i_, .div, .src1w, ._, ._, ._ },
                            .{ ._, ._, .@"and", .src1w, .sa(.src0, .add_smin), ._, ._ },
                            .{ ._, ._, .xor, .src1d, .tmp0d, ._, ._ },
                            .{ ._, ._, .cmp, .src1w, .sia(1, .src0, .add_smin), ._, ._ },
                            .{ ._, ._, .adc, .dst0d, .si(-1), ._, ._ },
                        } },
                    }, .{
                        .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                        .patterns = &.{
                            .{ .src = .{ .{ .to_reg = .ax }, .to_mut_gpr, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .i16, .kind = .{ .reg = .dx } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .cwd, ._, ._, ._, ._ },
                            .{ ._, .i_, .div, .src1w, ._, ._, ._ },
                            .{ ._, ._, .@"and", .src1d, .sa(.src0, .add_smin), ._, ._ },
                            .{ ._, ._, .xor, .src1d, .tmp0d, ._, ._ },
                            .{ ._, ._, .cmp, .src1w, .sia(1, .src0, .add_smin), ._, ._ },
                            .{ ._, ._, .adc, .dst0d, .si(-1), ._, ._ },
                        } },
                    }, .{
                        .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any },
                        .patterns = &.{
                            .{ .src = .{ .{ .to_reg = .eax }, .to_mut_gpr, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .i32, .kind = .{ .reg = .edx } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .cdq, ._, ._, ._, ._ },
                            .{ ._, .i_, .div, .src1d, ._, ._, ._ },
                            .{ ._, ._, .@"and", .src1d, .sa(.src0, .add_smin), ._, ._ },
                            .{ ._, ._, .xor, .src1d, .tmp0d, ._, ._ },
                            .{ ._, ._, .cmp, .src1d, .sia(1, .src0, .add_smin), ._, ._ },
                            .{ ._, ._, .adc, .dst0d, .si(-1), ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .@"64bit", null, null, null },
                        .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any },
                        .patterns = &.{
                            .{ .src = .{ .{ .to_reg = .rax }, .to_mut_gpr, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .i64, .kind = .{ .reg = .rdx } },
                            .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .cqo, ._, ._, ._, ._ },
                            .{ ._, .i_, .div, .src1q, ._, ._, ._ },
                            .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smin), ._, ._ },
                            .{ ._, ._, .@"and", .src1q, .tmp1q, ._, ._ },
                            .{ ._, ._, .xor, .src1q, .tmp0q, ._, ._ },
                            .{ ._, ._c, .st, ._, ._, ._, ._ },
                            .{ ._, ._, .sbb, .src1q, .tmp1q, ._, ._ },
                            .{ ._, ._, .adc, .dst0q, .si(-1), ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .src_constraints = .{ .{ .signed_int = .xword }, .{ .signed_int = .xword }, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .mem, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .i128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__modti3" } },
                            .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__divti3" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0q0, .mem(.src0q), ._, ._ },
                            .{ ._, ._, .mov, .tmp0q1, .memd(.src0q, 8), ._, ._ },
                            .{ ._, ._, .mov, .dst0q1, .mem(.src1q), ._, ._ },
                            .{ ._, ._, .mov, .tmp1q, .memd(.src1q, 8), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .mov, .tmp0q0, .ua(.src0, .add_smin), ._, ._ },
                            .{ ._, ._, .mov, .tmp1q, .memd(.src1q, 8), ._, ._ },
                            .{ ._, ._, .mov, .tmp0q1, .tmp0q0, ._, ._ },
                            .{ ._, ._, .@"and", .tmp0q1, .tmp1q, ._, ._ },
                            .{ ._, ._, .xor, .tmp0q1, .dst0q1, ._, ._ },
                            .{ ._, ._, .cmp, .dst0q0, .si(1), ._, ._ },
                            .{ ._, ._, .sbb, .tmp0q1, .tmp0q0, ._, ._ },
                            .{ ._, ._, .sbb, .tmp3q, .tmp3q, ._, ._ },
                            .{ ._, ._, .mov, .tmp0q0, .mem(.src0q), ._, ._ },
                            .{ ._, ._, .mov, .tmp0q1, .memd(.src0q, 8), ._, ._ },
                            .{ ._, ._, .mov, .dst0q1, .mem(.src1q), ._, ._ },
                            .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                            .{ ._, ._c, .st, ._, ._, ._, ._ },
                            .{ ._, ._, .sbb, .dst0q0, .tmp3q, ._, ._ },
                            .{ ._, ._, .sbb, .dst0q1, .tmp3q, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .@"64bit", null, null, null },
                        .src_constraints = .{
                            .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } },
                            .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } },
                            .any,
                        },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_mem, .to_mut_mem, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
                            .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__divei4" } },
                            .{ .kind = .{ .mem_of_type = .dst0 } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__modei4" } },
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                            .{ ._, ._, .lea, .tmp2p, .mem(.src1), ._, ._ },
                            .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                            .{ ._, ._, .mov, .tmp4d, .memad(.src0d, .add_size, -4), ._, ._ },
                            .{ ._, ._, .xor, .tmp4d, .memad(.src1d, .add_size, -4), ._, ._ },
                            .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                            .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ },
                            .{ ._, ._ns, .j, .@"0f", ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp6), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                            .{ ._, ._, .lea, .tmp2p, .mem(.src1), ._, ._ },
                            .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                            .{ ._, ._, .call, .tmp7d, ._, ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ },
                            .{ .@"1:", ._, .cmp, .memi(.tmp6q, .tmp0), .si(0), ._, ._ },
                            .{ ._, ._e, .j, .@"3f", ._, ._, ._ },
                            .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_size_div_8), ._, ._ },
                            .{ .@"2:", ._, .adc, .memsia(.dst0q, .@"8", .tmp0, .add_size), .si(-1), ._, ._ },
                            .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                            .{ ._, ._nz, .j, .@"2b", ._, ._, ._ },
                            .{ .@"3:", ._, .sub, .tmp0d, .si(8), ._, ._ },
                            .{ ._, ._ae, .j, .@"1b", ._, ._, ._ },
                        } },
                    } }),
                    .unsigned => res[0] = ops[0].divTruncInts(&ops[1], cg) catch |err| break :err err,
                } else cg.select(&res, &.{ty}, &ops, comptime &.{ .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
                        .{ ._, .v_ss, .div, .dst0x, .dst0x, .tmp0d, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        .{ ._, .v_ps, .cvtph2, .dst0x, .dst0q, ._, ._ },
                        .{ ._, .v_ss, .round, .dst0x, .dst0x, .dst0d, .rm(.{ .direction = .down, .precision = .inexact }) },
                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floorh" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .word } },
                        .{ .scalar_float = .{ .of = .qword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_4_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
                        .{ ._, .v_ps, .div, .dst0x, .dst0x, .tmp0x, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        .{ ._, .v_ps, .cvtph2, .dst0x, .dst0q, ._, ._ },
                        .{ ._, .v_ps, .round, .dst0x, .dst0x, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .word } },
                        .{ .scalar_float = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ },
                        .{ ._, .v_ps, .div, .dst0y, .dst0y, .tmp0y, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
                        .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                        .{ ._, .v_ps, .round, .dst0y, .dst0y, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_ps, .div, .tmp1y, .tmp1y, .tmp2y, ._ },
                        .{ ._, .v_, .cvtps2ph, .tmp1x, .tmp1y, .rm(.{}), ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp1y, .tmp1x, ._, ._ },
                        .{ ._, .v_ps, .round, .tmp1y, .tmp1y, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
                        .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floorh" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ },
                        .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
                        .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0) },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floorh" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                        .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floorh" } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                        .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .tmp5d, .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp5w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floorh" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ss, .div, .dst0x, .src0x, .src1d, ._ },
                        .{ ._, .v_ss, .round, .dst0x, .dst0x, .dst0d, .rm(.{ .direction = .down, .precision = .inexact }) },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._ss, .div, .dst0x, .src1d, ._, ._ },
                        .{ ._, ._ss, .round, .dst0x, .dst0d, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "floorf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._ss, .div, .dst0x, .src1d, ._, ._ },
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .div, .dst0x, .src0x, .src1x, ._ },
                        .{ ._, .v_ps, .round, .dst0x, .dst0x, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._ps, .div, .dst0x, .src1x, ._, ._ },
                        .{ ._, ._ps, .round, .dst0x, .dst0x, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "floorf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._ss, .div, .tmp1x, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .yword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .div, .dst0y, .src0y, .src1y, ._ },
                        .{ ._, .v_ps, .round, .dst0y, .dst0y, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_ps, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_ps, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_ps, .round, .tmp1y, .tmp1y, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
                        .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._ps, .div, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._ps, .round, .tmp1x, .tmp1x, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
                        .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_sd, .div, .dst0x, .src0x, .src1q, ._ },
                        .{ ._, .v_sd, .round, .dst0x, .dst0x, .dst0q, .rm(.{ .direction = .down, .precision = .inexact }) },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._sd, .div, .dst0x, .src1q, ._, ._ },
                        .{ ._, ._sd, .round, .dst0x, .dst0q, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "floor" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._sd, .div, .dst0x, .src1q, ._, ._ },
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__divdf3" } },
                        .{ .type = .usize, .kind = .{ .extern_func = "floor" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_pd, .div, .dst0x, .src0x, .src1x, ._ },
                        .{ ._, .v_pd, .round, .dst0x, .dst0x, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._pd, .div, .dst0x, .src1x, ._, ._ },
                        .{ ._, ._pd, .round, .dst0x, .dst0x, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .yword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .yword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_pd, .div, .dst0y, .src0y, .src1y, ._ },
                        .{ ._, .v_pd, .round, .dst0y, .dst0y, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_pd, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_pd, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_pd, .round, .tmp1y, .tmp1y, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
                        .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._pd, .div, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._pd, .round, .tmp1x, .tmp1x, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
                        .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "floor" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._sd, .div, .tmp1x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__divdf3" } },
                        .{ .type = .usize, .kind = .{ .extern_func = "floor" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._ps, .xor, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._ps, .movl, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floorx" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .reg = .st0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
                        .{ ._, .f_p, .div, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .mem(.tmp2t), ._, ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_cc_abi = .win64,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floorx" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ ._, .f_p, .div, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .lea(.tmp2t), ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3p, .tmp2p, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .msvc,
                    .required_cc_abi = .win64,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floorx" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
                        .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp3d, .memd(.tmp2b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_00_11), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp2b, 1), .tmp3b, ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .mem(.dst0), ._, ._ },
                        .{ ._, .f_p, .div, ._, ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
                        .{ ._, .f_p, .st, .lea(.tmp3t), ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp4p, .tmp3p, ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floorx" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, .f_p, .div, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .mem(.tmp3t), ._, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_cc_abi = .win64,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floorx" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, .f_p, .div, ._, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .f_p, .st, .lea(.tmp3t), ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp4p, .tmp3p, ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .msvc,
                    .required_cc_abi = .win64,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floorx" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, .fn_cw, .st, .tmp0w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp1d, .memd(.tmp0b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp0b, 1), .ui(0b000_0_00_11), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp0b, 1), .tmp1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp1, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, .f_, .ld, .memia(.src1t, .tmp1, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, .f_p, .div, ._, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp4p, .memia(.dst0, .tmp1, .add_unaligned_size), ._, ._ },
                        .{ ._, .f_p, .st, .lea(.tmp4t), ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5p, .tmp4p, ._, ._ },
                        .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
                        .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                        .{ .type = .usize, .kind = .{ .extern_func = "floorq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                        .{ .type = .f128, .kind = .mem },
                        .{ .type = .usize, .kind = .{ .extern_func = "floorq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                        .{ ._, .v_dqa, .mov, .lea(.tmp0x), .dst0x, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                        .{ .type = .f128, .kind = .mem },
                        .{ .type = .usize, .kind = .{ .extern_func = "floorq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                        .{ ._, ._dqa, .mov, .lea(.tmp0x), .dst0x, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                        .{ .type = .f128, .kind = .mem },
                        .{ .type = .usize, .kind = .{ .extern_func = "floorq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                        .{ ._, ._ps, .mova, .lea(.tmp0x), .dst0x, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                        .{ .type = .usize, .kind = .{ .extern_func = "floorq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp2x, .memi(.src1x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                        .{ .type = .usize, .kind = .{ .extern_func = "floorq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .memi(.src1x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                        .{ .type = .usize, .kind = .{ .extern_func = "floorq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._ps, .mova, .tmp2x, .memi(.src1x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                        .{ .type = .f128, .kind = .mem },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "floorq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memi(.src1x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp4), ._, ._ },
                        .{ ._, .v_dqa, .mov, .lea(.tmp1x), .tmp5x, ._, ._ },
                        .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp5x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                        .{ .type = .f128, .kind = .mem },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "floorq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memi(.src1x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp4), ._, ._ },
                        .{ ._, ._dqa, .mov, .lea(.tmp1x), .tmp5x, ._, ._ },
                        .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp5x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } },
                        .{ .type = .f128, .kind = .mem },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "floorq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memi(.src1x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp4), ._, ._ },
                        .{ ._, ._ps, .mova, .lea(.tmp1x), .tmp5x, ._, ._ },
                        .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp5x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                } })) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f} {f}", .{
                        @tagName(air_tag),
                        ty.fmt(pt),
                        ops[0].tracking(cg),
                        ops[1].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
            },
            .rem, .rem_optimized => |air_tag| {
                const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                var res: [1]Temp = undefined;
                cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{
                    .src_constraints = .{ .{ .exact_int = 1 }, .{ .exact_int = 1 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .any, .any, .none } },
                    },
                    .dst_temps = .{ .{ .imm = 0 }, .unused },
                    .each = .{ .once = &.{} },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                        .{ .src = .{ .to_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_gpr, .none } },
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .reg = .ah }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movsx, .dst0d, .src0b, ._, ._ },
                        .{ ._, .i_, .div, .src1b, ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                        .{ .src = .{ .to_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_gpr, .none } },
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .reg = .ah }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .dst0d, .src0b, ._, ._ },
                        .{ ._, ._, .div, .src1b, ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .ax }, .mem, .none } },
                        .{ .src = .{ .{ .to_reg = .ax }, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .reg = .dx }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cwd, ._, ._, ._, ._ },
                        .{ ._, .i_, .div, .src1w, ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .ax }, .mem, .none } },
                        .{ .src = .{ .{ .to_reg = .ax }, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .reg = .dx }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                        .{ ._, ._, .div, .src1w, ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .eax }, .mem, .none } },
                        .{ .src = .{ .{ .to_reg = .eax }, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .reg = .edx }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cdq, ._, ._, ._, ._ },
                        .{ ._, .i_, .div, .src1d, ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .eax }, .mem, .none } },
                        .{ .src = .{ .{ .to_reg = .eax }, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .reg = .edx }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                        .{ ._, ._, .div, .src1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .rax }, .mem, .none } },
                        .{ .src = .{ .{ .to_reg = .rax }, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .reg = .rdx }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cqo, ._, ._, ._, ._ },
                        .{ ._, .i_, .div, .src1q, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .rax }, .mem, .none } },
                        .{ .src = .{ .{ .to_reg = .rax }, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .reg = .rdx }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .dst0q, .dst0q, ._, ._ },
                        .{ ._, ._, .div, .src1q, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .src_constraints = .{ .{ .signed_int = .xword }, .{ .signed_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 2, .at = 2 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__modti3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .xword }, .{ .signed_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__modti3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .src_constraints = .{ .{ .unsigned_int = .xword }, .{ .unsigned_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 2, .at = 2 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__umodti3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .xword }, .{ .unsigned_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__umodti3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } },
                        .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_mem, .to_mut_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__modei4" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } },
                        .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__umodei4" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .reg = .ax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .i_, .div, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .movsx, .tmp1d, .tmp1h, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1l, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .reg = .ax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .i_, .div, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .movsx, .tmp1d, .tmp1h, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1l, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .reg = .ax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .div, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp1d, .tmp1h, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1l, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .reg = .ax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .div, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp1d, .tmp1h, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1l, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .reg = .ax } },
                        .{ .type = .i16, .kind = .{ .reg = .dx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .cwd, ._, ._, ._, ._ },
                        .{ ._, .i_, .div, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .reg = .ax } },
                        .{ .type = .u16, .kind = .{ .reg = .dx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._, .div, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .reg = .eax } },
                        .{ .type = .i32, .kind = .{ .reg = .edx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .cdq, ._, ._, ._, ._ },
                        .{ ._, .i_, .div, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .reg = .eax } },
                        .{ .type = .u32, .kind = .{ .reg = .edx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._, .div, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .reg = .rax } },
                        .{ .type = .i64, .kind = .{ .reg = .rdx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .cqo, ._, ._, ._, ._ },
                        .{ ._, .i_, .div, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._, .div, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__modti3" } },
                        .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .memiad(.src1q, .tmp0, .add_unaligned_size, 8), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp3q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__umodti3" } },
                        .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .memiad(.src1q, .tmp0, .add_unaligned_size, 8), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp3q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } },
                        .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_mem, .to_mut_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__modei4" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .memia(.src1, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp4d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } },
                        .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_mem, .to_mut_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__umodei4" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .memia(.src1, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp4d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ },
                        .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
                        .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0) },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                        .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                        .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .tmp4d, .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "fmodf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmodf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_ss, .mov, .tmp2x, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmodf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._ss, .mov, .tmp2x, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "fmod" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmod" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_sd, .mov, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .v_sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmod" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._sd, .mov, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmod" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._ps, .xor, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._ps, .movl, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, .x87, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .reg = .st0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, .v_dqa, .mov, .tmp0x, .mem(.src0x), ._, ._ },
                        .{ ._, .v_dqa, .mov, .mem(.tmp1x), .tmp0x, ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp0x, .mem(.src1x), ._, ._ },
                        .{ ._, .v_dqa, .mov, .memd(.tmp1x, 16), .tmp0x, ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, .x87, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .reg = .st0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._dqa, .mov, .tmp0x, .mem(.src0x), ._, ._ },
                        .{ ._, ._dqa, .mov, .mem(.tmp1x), .tmp0x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp0x, .mem(.src1x), ._, ._ },
                        .{ ._, ._dqa, .mov, .memd(.tmp1x, 16), .tmp0x, ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, .x87, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .reg = .st0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._ps, .mova, .tmp0x, .mem(.src0x), ._, ._ },
                        .{ ._, ._ps, .mova, .mem(.tmp1x), .tmp0x, ._, ._ },
                        .{ ._, ._ps, .mova, .tmp0x, .mem(.src1x), ._, ._ },
                        .{ ._, ._ps, .mova, .memd(.tmp1x, 16), .tmp0x, ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, .x87, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .memd(.tmp2x, 16), .tmp1x, ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, .x87, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memd(.tmp2x, 16), .tmp1x, ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, .x87, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._ps, .mova, .mem(.tmp2x), .tmp1x, ._, ._ },
                        .{ ._, ._ps, .mova, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._ps, .mova, .memd(.tmp2x, 16), .tmp1x, ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .memia(.src1, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "fmodq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmodq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmodq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp2x, .memi(.src1x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmodq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .memi(.src1x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmodq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._ps, .mova, .tmp2x, .memi(.src1x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmodq" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memi(.src1, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp4x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmodq" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memi(.src1, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp4x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmodq" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memi(.src1, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp4x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f} {f}", .{
                        @tagName(air_tag),
                        cg.typeOf(bin_op.lhs).fmt(pt),
                        ops[0].tracking(cg),
                        ops[1].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
            },
            .mod, .mod_optimized => |air_tag| {
                const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                var res: [1]Temp = undefined;
                cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{
                    .src_constraints = .{ .{ .exact_int = 1 }, .{ .exact_int = 1 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .any, .any, .none } },
                    },
                    .dst_temps = .{ .{ .imm = 0 }, .unused },
                    .each = .{ .once = &.{} },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .to_mut_gphi, .none } },
                        .{ .src = .{ .to_gpr, .to_mut_gphi, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i8, .kind = .{ .rc = .gphi } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .reg = .ah }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movsx, .dst0d, .src0b, ._, ._ },
                        .{ ._, .i_, .div, .src1b, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._, .add, .tmp0h, .src1b, ._, ._ },
                        .{ ._, ._, .@"and", .src1b, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .src1b, .dst0h, ._, ._ },
                        .{ ._, ._, .cmp, .src1b, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._a, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .to_gphi, .none } },
                        .{ .src = .{ .to_gpr, .to_gphi, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i8, .kind = .{ .rc = .gphi } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .reg = .ah }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movsx, .dst0d, .src0b, ._, ._ },
                        .{ ._, .i_, .div, .src1b, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .src1d, ._, ._ },
                        .{ ._, ._, .@"and", .tmp0b, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp0b, .dst0h, ._, ._ },
                        .{ ._, ._, .cmp, .tmp0b, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .add, .dst0h, .src1b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                        .{ .src = .{ .to_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_gpr, .none } },
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .reg = .ah }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .dst0d, .src0b, ._, ._ },
                        .{ ._, ._, .div, .src1b, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .fast_imm16, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .ax }, .to_mut_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .reg = .dx }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cwd, ._, ._, ._, ._ },
                        .{ ._, .i_, .div, .src1w, ._, ._, ._ },
                        .{ ._, ._, .mov, .src0d, .dst0d, ._, ._ },
                        .{ ._, ._, .add, .src0d, .src1d, ._, ._ },
                        .{ ._, ._, .@"and", .src1w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .src1d, .dst0d, ._, ._ },
                        .{ ._, ._, .cmp, .src1w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._a, .cmov, .dst0d, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .ax }, .to_mut_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .reg = .dx }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cwd, ._, ._, ._, ._ },
                        .{ ._, .i_, .div, .src1w, ._, ._, ._ },
                        .{ ._, ._, .mov, .src0d, .dst0d, ._, ._ },
                        .{ ._, ._, .add, .src0d, .src1d, ._, ._ },
                        .{ ._, ._, .@"and", .src1d, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .src1d, .dst0d, ._, ._ },
                        .{ ._, ._, .cmp, .src1w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._a, .cmov, .dst0d, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .ax }, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .reg = .dx }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cwd, ._, ._, ._, ._ },
                        .{ ._, .i_, .div, .src1w, ._, ._, ._ },
                        .{ ._, ._, .mov, .src0d, .src1d, ._, ._ },
                        .{ ._, ._, .@"and", .src0w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .src0d, .dst0d, ._, ._ },
                        .{ ._, ._, .cmp, .src0w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .add, .dst0d, .src1d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .ax }, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .reg = .dx }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cwd, ._, ._, ._, ._ },
                        .{ ._, .i_, .div, .src1w, ._, ._, ._ },
                        .{ ._, ._, .mov, .src0d, .src1d, ._, ._ },
                        .{ ._, ._, .@"and", .src0d, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .src0d, .dst0d, ._, ._ },
                        .{ ._, ._, .cmp, .src0w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .add, .dst0d, .src1d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .ax }, .mem, .none } },
                        .{ .src = .{ .{ .to_reg = .ax }, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .reg = .dx }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                        .{ ._, ._, .div, .src1w, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .eax }, .to_mut_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .reg = .edx }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cdq, ._, ._, ._, ._ },
                        .{ ._, .i_, .div, .src1d, ._, ._, ._ },
                        .{ ._, ._, .mov, .src0d, .dst0d, ._, ._ },
                        .{ ._, ._, .add, .src0d, .src1d, ._, ._ },
                        .{ ._, ._, .@"and", .src1d, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .src1d, .dst0d, ._, ._ },
                        .{ ._, ._, .cmp, .src1d, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._a, .cmov, .dst0d, .src0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .eax }, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .reg = .edx }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cdq, ._, ._, ._, ._ },
                        .{ ._, .i_, .div, .src1d, ._, ._, ._ },
                        .{ ._, ._, .mov, .src0d, .src1d, ._, ._ },
                        .{ ._, ._, .@"and", .src0d, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .src0d, .dst0d, ._, ._ },
                        .{ ._, ._, .cmp, .src0d, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .add, .dst0d, .src1d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .eax }, .mem, .none } },
                        .{ .src = .{ .{ .to_reg = .eax }, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .reg = .edx }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                        .{ ._, ._, .div, .src1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .rax }, .to_mut_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .reg = .rdx }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cqo, ._, ._, ._, ._ },
                        .{ ._, .i_, .div, .src1q, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .mov, .src0q, .dst0q, ._, ._ },
                        .{ ._, ._, .add, .src0q, .src1q, ._, ._ },
                        .{ ._, ._, .@"and", .src1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .xor, .src1q, .dst0q, ._, ._ },
                        .{ ._, ._, .cmp, .src1q, .tmp0q, ._, ._ },
                        .{ ._, ._a, .cmov, .dst0q, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .rax }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .reg = .rdx }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cqo, ._, ._, ._, ._ },
                        .{ ._, .i_, .div, .src1q, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .mov, .src0q, .src1q, ._, ._ },
                        .{ ._, ._, .@"and", .src0q, .tmp0q, ._, ._ },
                        .{ ._, ._, .xor, .src0q, .dst0q, ._, ._ },
                        .{ ._, ._, .cmp, .src0q, .tmp0q, ._, ._ },
                        .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .add, .dst0q, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .rax }, .mem, .none } },
                        .{ .src = .{ .{ .to_reg = .rax }, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .reg = .rdx }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .dst0q, .dst0q, ._, ._ },
                        .{ ._, ._, .div, .src1q, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{ .{ .signed_int = .xword }, .{ .signed_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__modti3" } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0q1, .mem(.src1q), ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .memd(.src1q, 8), ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                        .{ ._, ._, .mov, .src0q0, .memd(.src1q, 8), ._, ._ },
                        .{ ._, ._, .mov, .src0q1, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .src0q0, ._, ._ },
                        .{ ._, ._, .@"and", .tmp0q, .src0q1, ._, ._ },
                        .{ ._, ._, .xor, .tmp0q, .dst0q1, ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._, .cmp, .dst0q0, .si(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp0q, .src0q1, ._, ._ },
                        .{ ._, ._nae, .cmov, .src0q0, .tmp2q, ._, ._ },
                        .{ ._, ._ae, .cmov, .tmp2q, .mem(.src1q), ._, ._ },
                        .{ ._, ._, .add, .dst0q0, .tmp2q, ._, ._ },
                        .{ ._, ._, .adc, .dst0q1, .src0q0, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .signed_int = .xword }, .{ .signed_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__modti3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0q1, .mem(.src1q), ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .memd(.src1q, 8), ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                        .{ ._, ._, .mov, .src0q0, .memd(.src1q, 8), ._, ._ },
                        .{ ._, ._, .mov, .src0q1, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .src0q0, ._, ._ },
                        .{ ._, ._, .@"and", .tmp0q, .src0q1, ._, ._ },
                        .{ ._, ._, .xor, .tmp0q, .dst0q1, ._, ._ },
                        .{ ._, ._, .cmp, .dst0q0, .si(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp0q, .src0q1, ._, ._ },
                        .{ ._, ._nae, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .add, .dst0q0, .mem(.src1q), ._, ._ },
                        .{ ._, ._, .adc, .dst0q1, .src0q0, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .@"64bit", .cmov, .avx, null },
                    .src_constraints = .{ .{ .signed_int = .xword }, .{ .signed_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__modti3" } },
                        .{ .type = .i128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .u64, .kind = .{ .reg = .r8 } },
                        .{ .type = .u64, .kind = .{ .reg = .r9 } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .r10 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0q0, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .dst0q1, .mem(.src1), ._, ._ },
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                        .{ ._, .v_q, .mov, .dst0q0, .tmp1x, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .memd(.src1q, 8), ._, ._ },
                        .{ ._, .vp_q, .extr, .dst0q1, .tmp1x, .ui(1), ._ },
                        .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp4q, .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp4q, .dst0q1, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .cmp, .dst0q0, .si(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp4q, .tmp3q, ._, ._ },
                        .{ ._, ._nae, .cmov, .tmp2q, .tmp5q, ._, ._ },
                        .{ ._, ._ae, .cmov, .tmp5q, .mem(.src1q), ._, ._ },
                        .{ ._, ._, .add, .dst0q0, .tmp5q, ._, ._ },
                        .{ ._, ._, .adc, .dst0q1, .tmp2q, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .@"64bit", .cmov, .sse4_1, null },
                    .src_constraints = .{ .{ .signed_int = .xword }, .{ .signed_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__modti3" } },
                        .{ .type = .i128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .u64, .kind = .{ .reg = .r8 } },
                        .{ .type = .u64, .kind = .{ .reg = .r9 } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .r10 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0q0, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .dst0q1, .mem(.src1), ._, ._ },
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                        .{ ._, ._q, .mov, .dst0q0, .tmp1x, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .memd(.src1q, 8), ._, ._ },
                        .{ ._, .p_q, .extr, .dst0q1, .tmp1x, .ui(1), ._ },
                        .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp4q, .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp4q, .dst0q1, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .cmp, .dst0q0, .si(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp4q, .tmp3q, ._, ._ },
                        .{ ._, ._nae, .cmov, .tmp2q, .tmp5q, ._, ._ },
                        .{ ._, ._ae, .cmov, .tmp5q, .mem(.src1q), ._, ._ },
                        .{ ._, ._, .add, .dst0q0, .tmp5q, ._, ._ },
                        .{ ._, ._, .adc, .dst0q1, .tmp2q, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .@"64bit", .cmov, .sse2, null },
                    .src_constraints = .{ .{ .signed_int = .xword }, .{ .signed_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__modti3" } },
                        .{ .type = .i128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .u64, .kind = .{ .reg = .r8 } },
                        .{ .type = .u64, .kind = .{ .reg = .r9 } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .r10 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0q0, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .dst0q1, .mem(.src1), ._, ._ },
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                        .{ ._, ._q, .mov, .dst0q0, .tmp1x, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .memd(.src1q, 8), ._, ._ },
                        .{ ._, .p_d, .shuf, .tmp1x, .tmp1x, .ui(0b11_10_11_10), ._ },
                        .{ ._, ._q, .mov, .dst0q1, .tmp1x, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp4q, .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp4q, .dst0q1, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .cmp, .dst0q0, .si(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp4q, .tmp3q, ._, ._ },
                        .{ ._, ._nae, .cmov, .tmp2q, .tmp5q, ._, ._ },
                        .{ ._, ._ae, .cmov, .tmp5q, .mem(.src1q), ._, ._ },
                        .{ ._, ._, .add, .dst0q0, .tmp5q, ._, ._ },
                        .{ ._, ._, .adc, .dst0q1, .tmp2q, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .@"64bit", .cmov, .sse, null },
                    .src_constraints = .{ .{ .signed_int = .xword }, .{ .signed_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__modti3" } },
                        .{ .type = .i128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .i128, .kind = .mem },
                        .{ .type = .u64, .kind = .{ .reg = .r8 } },
                        .{ .type = .u64, .kind = .{ .reg = .r9 } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .r10 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0q0, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .dst0q1, .mem(.src1), ._, ._ },
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .mem(.tmp2x), .tmp1x, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memd(.src1q, 8), ._, ._ },
                        .{ ._, ._, .mov, .dst0q0, .mem(.tmp2q), ._, ._ },
                        .{ ._, ._, .mov, .dst0q1, .memd(.tmp2q, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp5q, .tmp4q, ._, ._ },
                        .{ ._, ._, .xor, .tmp5q, .dst0q1, ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .cmp, .dst0q0, .si(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp5q, .tmp4q, ._, ._ },
                        .{ ._, ._nae, .cmov, .tmp3q, .tmp6q, ._, ._ },
                        .{ ._, ._ae, .cmov, .tmp6q, .mem(.src1q), ._, ._ },
                        .{ ._, ._, .add, .dst0q0, .tmp6q, ._, ._ },
                        .{ ._, ._, .adc, .dst0q1, .tmp3q, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{ .{ .signed_int = .xword }, .{ .signed_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__modti3" } },
                        .{ .type = .i128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .u64, .kind = .{ .reg = .r8 } },
                        .{ .type = .u64, .kind = .{ .reg = .r9 } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0q0, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .dst0q1, .mem(.src1), ._, ._ },
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                        .{ ._, .v_q, .mov, .dst0q0, .tmp1x, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .memd(.src1q, 8), ._, ._ },
                        .{ ._, .vp_q, .extr, .dst0q1, .tmp1x, .ui(1), ._ },
                        .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp4q, .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp4q, .dst0q1, ._, ._ },
                        .{ ._, ._, .cmp, .dst0q0, .si(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp4q, .tmp3q, ._, ._ },
                        .{ ._, ._nae, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .add, .dst0q0, .mem(.src1x), ._, ._ },
                        .{ ._, ._, .adc, .dst0q1, .tmp2q, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .@"64bit", .sse4_1, null, null },
                    .src_constraints = .{ .{ .signed_int = .xword }, .{ .signed_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__modti3" } },
                        .{ .type = .i128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .u64, .kind = .{ .reg = .r8 } },
                        .{ .type = .u64, .kind = .{ .reg = .r9 } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0q0, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .dst0q1, .mem(.src1), ._, ._ },
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                        .{ ._, ._q, .mov, .dst0q0, .tmp1x, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .memd(.src1q, 8), ._, ._ },
                        .{ ._, .p_q, .extr, .dst0q1, .tmp1x, .ui(1), ._ },
                        .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp4q, .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp4q, .dst0q1, ._, ._ },
                        .{ ._, ._, .cmp, .dst0q0, .si(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp4q, .tmp3q, ._, ._ },
                        .{ ._, ._nae, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .add, .dst0q0, .mem(.src1x), ._, ._ },
                        .{ ._, ._, .adc, .dst0q1, .tmp2q, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .@"64bit", .sse2, null, null },
                    .src_constraints = .{ .{ .signed_int = .xword }, .{ .signed_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__modti3" } },
                        .{ .type = .i128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .u64, .kind = .{ .reg = .r8 } },
                        .{ .type = .u64, .kind = .{ .reg = .r9 } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0q0, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .dst0q1, .mem(.src1), ._, ._ },
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                        .{ ._, ._q, .mov, .dst0q0, .tmp1x, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .memd(.src1q, 8), ._, ._ },
                        .{ ._, .p_d, .shuf, .tmp1x, .tmp1x, .ui(0b11_10_11_10), ._ },
                        .{ ._, ._q, .mov, .dst0q1, .tmp1x, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp4q, .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp4q, .dst0q1, ._, ._ },
                        .{ ._, ._, .cmp, .dst0q0, .si(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp4q, .tmp3q, ._, ._ },
                        .{ ._, ._nae, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .add, .dst0q0, .mem(.src1x), ._, ._ },
                        .{ ._, ._, .adc, .dst0q1, .tmp2q, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .signed_int = .xword }, .{ .signed_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__modti3" } },
                        .{ .type = .i128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .i128, .kind = .mem },
                        .{ .type = .u64, .kind = .{ .reg = .r8 } },
                        .{ .type = .u64, .kind = .{ .reg = .r9 } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0q0, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .dst0q1, .mem(.src1), ._, ._ },
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .mem(.tmp2x), .tmp1x, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memd(.src1q, 8), ._, ._ },
                        .{ ._, ._, .mov, .dst0q0, .mem(.tmp2q), ._, ._ },
                        .{ ._, ._, .mov, .dst0q1, .memd(.tmp2q, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp5q, .tmp4q, ._, ._ },
                        .{ ._, ._, .xor, .tmp5q, .dst0q1, ._, ._ },
                        .{ ._, ._, .cmp, .dst0q0, .si(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp5q, .tmp4q, ._, ._ },
                        .{ ._, ._nae, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .add, .dst0q0, .mem(.src1x), ._, ._ },
                        .{ ._, ._, .adc, .dst0q1, .tmp3q, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .src_constraints = .{ .{ .unsigned_int = .xword }, .{ .unsigned_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 2, .at = 2 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__umodti3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .xword }, .{ .unsigned_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__umodti3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } },
                        .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_mem, .to_mut_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__modei4" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-3, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp4q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp2q, .tmp1q, ._, ._ },
                        .{ ._, ._, .xor, .tmp2q, .memad(.dst0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .cmp, .memad(.dst0q, .add_size, -16), .si(1), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp3q, .memsi(.dst0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .sbb, .tmp3q, .si(0), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .sbb, .tmp2q, .tmp1q, ._, ._ },
                        .{ ._, ._nae, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src1, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp4q, .tmp4q, ._, ._ },
                        .{ ._, ._ns, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp1q, .memsia(.src1q, .@"8", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .sbb, .memsia(.dst0q, .@"8", .tmp0, .add_size), .tmp1q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._mp, .j, .@"0f", ._, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp1q, .memsia(.src1q, .@"8", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .memsia(.dst0q, .@"8", .tmp0, .add_size), .tmp1q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"2b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } },
                        .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__umodei4" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, .fast_imm16, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } },
                        .{ .type = .f16, .kind = .{ .reg = .dx } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, .v_d, .mov, .tmp0d, .src1x, ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                        .{ ._, .v_d, .mov, .tmp2d, .dst0x, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .@"and", .tmp3w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp2d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp3w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
                        .{ ._, .v_d, .mov, .src1x, .tmp0d, ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .src0x, .src0q, ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .src1x, .src1q, ._, ._ },
                        .{ ._, .v_ss, .add, .dst0x, .src0x, .src1d, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } },
                        .{ .type = .f16, .kind = .{ .reg = .dx } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, .v_d, .mov, .tmp0d, .src1x, ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                        .{ ._, .v_d, .mov, .tmp2d, .dst0x, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .@"and", .tmp3d, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp2d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp3w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
                        .{ ._, .v_d, .mov, .src1x, .tmp0d, ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .src0x, .src0q, ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .src1x, .src1q, ._, ._ },
                        .{ ._, .v_ss, .add, .dst0x, .src0x, .src1d, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, .fast_imm16, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } },
                        .{ .type = .f16, .kind = .{ .reg = .dx } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, .v_d, .mov, .tmp0d, .src1x, ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                        .{ ._, .v_d, .mov, .tmp2d, .dst0x, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .@"and", .tmp3w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp2d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp3w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
                        .{ ._, .v_d, .mov, .src1x, .tmp0d, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } },
                        .{ .type = .f16, .kind = .{ .reg = .dx } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, .v_d, .mov, .tmp0d, .src1x, ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                        .{ ._, .v_d, .mov, .tmp2d, .dst0x, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .@"and", .tmp3d, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp2d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp3w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
                        .{ ._, .v_d, .mov, .src1x, .tmp0d, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, .fast_imm16, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } },
                        .{ .type = .f16, .kind = .{ .reg = .dx } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._d, .mov, .tmp0d, .src1x, ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                        .{ ._, ._d, .mov, .tmp2d, .dst0x, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .@"and", .tmp3w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp2d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp3w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._d, .mov, .src1x, .tmp0d, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } },
                        .{ .type = .f16, .kind = .{ .reg = .dx } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._d, .mov, .tmp0d, .src1x, ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                        .{ ._, ._d, .mov, .tmp2d, .dst0x, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .@"and", .tmp3d, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp2d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp3w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._d, .mov, .src1x, .tmp0d, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, .fast_imm16, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._ss, .mov, .mem(.tmp0d), .src1x, ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .mem(.tmp2d), .dst0x, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .mem(.tmp0d), ._, ._ },
                        .{ ._, ._, .@"and", .tmp3w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .cmp, .tmp3w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._ss, .mov, .src1x, .mem(.tmp0d), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._ss, .mov, .mem(.tmp0d), .src1x, ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .mem(.tmp2d), .dst0x, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .@"and", .tmp3d, .mem(.tmp0d), ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .cmp, .tmp3w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._ss, .mov, .src1x, .mem(.tmp0d), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, .fast_imm16, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } },
                        .{ .type = .f16, .kind = .{ .reg = .dx } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0x, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
                        .{ ._, ._, .movzx, .tmp2d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_d, .mov, .tmp3x, .tmp2d, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, .v_d, .mov, .tmp5d, .tmp1x, ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .tmp2d, ._, ._ },
                        .{ ._, ._, .@"and", .tmp6w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp5d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp6w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, .v_d, .mov, .tmp3x, .tmp2d, ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp3x, .tmp3x, ._, ._ },
                        .{ ._, .v_ss, .add, .tmp1x, .tmp1x, .tmp3d, ._ },
                        .{ ._, .v_, .cvtps2ph, .tmp1q, .tmp1x, .rm(.{}), ._ },
                        .{ .@"1:", .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } },
                        .{ .type = .f16, .kind = .{ .reg = .dx } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0x, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
                        .{ ._, ._, .movzx, .tmp2d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_d, .mov, .tmp3x, .tmp2d, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, .v_d, .mov, .tmp5d, .tmp1x, ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .tmp2d, ._, ._ },
                        .{ ._, ._, .@"and", .tmp6d, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp5d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp6w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, .v_d, .mov, .tmp3x, .tmp2d, ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp3x, .tmp3x, ._, ._ },
                        .{ ._, .v_ss, .add, .tmp1x, .tmp1x, .tmp3d, ._ },
                        .{ ._, .v_, .cvtps2ph, .tmp1q, .tmp1x, .rm(.{}), ._ },
                        .{ .@"1:", .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, .fast_imm16, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } },
                        .{ .type = .f16, .kind = .{ .reg = .dx } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0x, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
                        .{ ._, ._, .movzx, .tmp2d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_d, .mov, .tmp3x, .tmp2d, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, .v_d, .mov, .tmp5d, .tmp1x, ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .tmp2d, ._, ._ },
                        .{ ._, ._, .@"and", .tmp6w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp5d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp6w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, .v_d, .mov, .tmp3x, .tmp2d, ._, ._ },
                        .{ ._, ._, .call, .tmp7d, ._, ._, ._ },
                        .{ .@"1:", .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } },
                        .{ .type = .f16, .kind = .{ .reg = .dx } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0x, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
                        .{ ._, ._, .movzx, .tmp2d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_d, .mov, .tmp3x, .tmp2d, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, .v_d, .mov, .tmp5d, .tmp1x, ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .tmp2d, ._, ._ },
                        .{ ._, ._, .@"and", .tmp6d, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp5d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp6w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, .v_d, .mov, .tmp3x, .tmp2d, ._, ._ },
                        .{ ._, ._, .call, .tmp7d, ._, ._, ._ },
                        .{ .@"1:", .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, .fast_imm16, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } },
                        .{ .type = .f16, .kind = .{ .reg = .dx } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0x, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                        .{ ._, ._, .movzx, .tmp2d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._d, .mov, .tmp3x, .tmp2d, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._d, .mov, .tmp5d, .tmp1x, ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .tmp2d, ._, ._ },
                        .{ ._, ._, .@"and", .tmp6w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp5d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp6w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._d, .mov, .tmp3x, .tmp2d, ._, ._ },
                        .{ ._, ._, .call, .tmp7d, ._, ._, ._ },
                        .{ .@"1:", .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } },
                        .{ .type = .f16, .kind = .{ .reg = .dx } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0x, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                        .{ ._, ._, .movzx, .tmp2d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._d, .mov, .tmp3x, .tmp2d, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._d, .mov, .tmp5d, .tmp1x, ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .tmp2d, ._, ._ },
                        .{ ._, ._, .@"and", .tmp6d, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp5d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp6w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._d, .mov, .tmp3x, .tmp2d, ._, ._ },
                        .{ ._, ._, .call, .tmp7d, ._, ._, ._ },
                        .{ .@"1:", .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, .fast_imm16, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } },
                        .{ .type = .f16, .kind = .{ .reg = .dx } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0x, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                        .{ ._, ._, .movzx, .tmp2d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._d, .mov, .tmp3x, .tmp2d, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._d, .mov, .tmp5d, .tmp1x, ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .tmp2d, ._, ._ },
                        .{ ._, ._, .@"and", .tmp6w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp5d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp6w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._d, .mov, .tmp3x, .tmp2d, ._, ._ },
                        .{ ._, ._, .call, .tmp7d, ._, ._, ._ },
                        .{ ._, ._d, .mov, .tmp5d, .tmp1x, ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp5w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } },
                        .{ .type = .f16, .kind = .{ .reg = .dx } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0x, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                        .{ ._, ._, .movzx, .tmp2d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._d, .mov, .tmp3x, .tmp2d, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._d, .mov, .tmp5d, .tmp1x, ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .tmp2d, ._, ._ },
                        .{ ._, ._, .@"and", .tmp6d, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp5d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp6w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._d, .mov, .tmp3x, .tmp2d, ._, ._ },
                        .{ ._, ._, .call, .tmp7d, ._, ._, ._ },
                        .{ ._, ._d, .mov, .tmp5d, .tmp1x, ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp5w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, .fast_imm16, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0x, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .mem(.tmp6d), .tmp3x, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .mem(.tmp6d), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .call, .tmp7d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .mem(.tmp6d), .tmp3x, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp1d, .mem(.tmp6d), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0x, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .mem(.tmp6d), .tmp3x, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1d, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .mem(.tmp6d), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .call, .tmp7d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .mem(.tmp6d), .tmp3x, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp1d, .mem(.tmp6d), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmodf" } },
                        .{ .type = .f32, .kind = .{ .reg = .edx } },
                        .{ .type = .f32, .kind = .{ .reg = .eax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, .v_d, .mov, .tmp0d, .src1x, ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                        .{ ._, .v_d, .mov, .tmp2d, .dst0x, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .@"and", .tmp3d, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp2d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp3d, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
                        .{ ._, .v_d, .mov, .src1x, .tmp0d, ._, ._ },
                        .{ ._, .v_ss, .add, .dst0x, .src0x, .src1d, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmodf" } },
                        .{ .type = .f32, .kind = .{ .reg = .edx } },
                        .{ .type = .f32, .kind = .{ .reg = .eax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._d, .mov, .tmp0d, .src1x, ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                        .{ ._, ._d, .mov, .tmp2d, .dst0x, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .@"and", .tmp3d, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp2d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp3d, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._d, .mov, .src1x, .tmp0d, ._, ._ },
                        .{ ._, ._ss, .add, .dst0x, .src1d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmodf" } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f32, .kind = .{ .reg = .eax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._ss, .mov, .mem(.tmp0d), .src1x, ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .mem(.tmp2d), .dst0x, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .@"and", .tmp3d, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .cmp, .tmp3d, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._ss, .add, .dst0x, .mem(.tmp0d), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmodf" } },
                        .{ .type = .f32, .kind = .{ .reg = .edx } },
                        .{ .type = .f32, .kind = .{ .reg = .eax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_ss, .mov, .tmp2x, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_d, .mov, .tmp3d, .tmp2x, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, .v_d, .mov, .tmp5d, .tmp1x, ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .tmp3d, ._, ._ },
                        .{ ._, ._, .@"and", .tmp6d, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp5d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp6d, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, .v_d, .mov, .tmp2x, .tmp3d, ._, ._ },
                        .{ ._, .v_ss, .add, .tmp1x, .tmp1x, .tmp2d, ._ },
                        .{ .@"1:", .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmodf" } },
                        .{ .type = .f32, .kind = .{ .reg = .edx } },
                        .{ .type = .f32, .kind = .{ .reg = .eax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._ss, .mov, .tmp2x, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._d, .mov, .tmp3d, .tmp2x, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._d, .mov, .tmp5d, .tmp1x, ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .tmp3d, ._, ._ },
                        .{ ._, ._, .@"and", .tmp6d, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp5d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp6d, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._d, .mov, .tmp2x, .tmp3d, ._, ._ },
                        .{ ._, ._ss, .add, .tmp1x, .tmp2d, ._, ._ },
                        .{ .@"1:", ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmodf" } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f32, .kind = .{ .reg = .eax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._ss, .mov, .tmp2x, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .mem(.tmp4d), .tmp1x, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .@"and", .tmp5d, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .mem(.tmp4d), ._, ._ },
                        .{ ._, ._, .cmp, .tmp5d, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._ss, .add, .tmp1x, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ .@"1:", ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmod" } },
                        .{ .type = .f64, .kind = .{ .reg = .rcx } },
                        .{ .type = .f64, .kind = .{ .reg = .rdx } },
                        .{ .type = .f64, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, .v_q, .mov, .tmp0q, .src1x, ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, .v_q, .mov, .tmp3q, .dst0x, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp0q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._, .xor, .tmp4q, .tmp3q, ._, ._ },
                        .{ ._, ._, .cmp, .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
                        .{ ._, .v_q, .mov, .src1q, .tmp0q, ._, ._ },
                        .{ ._, .v_sd, .add, .dst0x, .src0x, .src1q, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse2, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmod" } },
                        .{ .type = .f64, .kind = .{ .reg = .rcx } },
                        .{ .type = .f64, .kind = .{ .reg = .rdx } },
                        .{ .type = .f64, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._q, .mov, .tmp0q, .src1x, ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._q, .mov, .tmp3q, .dst0x, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp0q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._, .xor, .tmp4q, .tmp3q, ._, ._ },
                        .{ ._, ._, .cmp, .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._q, .mov, .src1x, .tmp0q, ._, ._ },
                        .{ ._, ._sd, .add, .dst0x, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f64, .kind = .mem },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmod" } },
                        .{ .type = .f64, .kind = .mem },
                        .{ .type = .f64, .kind = .{ .reg = .rdx } },
                        .{ .type = .f64, .kind = .{ .reg = .rax } },
                        .{ .type = .f64, .kind = .{ .reg = .st6 } },
                        .{ .type = .f64, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._ps, .movl, .mem(.tmp0q), .src1x, ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._ps, .movl, .mem(.tmp2q), .dst0x, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp0q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp4q, .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp4q, .mem(.tmp2q), ._, ._ },
                        .{ ._, ._, .cmp, .tmp4q, .tmp3q, ._, ._ },
                        .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
                        .{ ._, .f_, .ld, .mem(.tmp2q), ._, ._, ._ },
                        .{ ._, .f_, .add, .mem(.tmp0q), ._, ._, ._ },
                        .{ ._, .f_p, .st, .mem(.tmp2q), ._, ._, ._ },
                        .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ },
                        .{ ._, ._ps, .movl, .dst0x, .mem(.tmp2q), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmod" } },
                        .{ .type = .f64, .kind = .{ .reg = .rcx } },
                        .{ .type = .f64, .kind = .{ .reg = .rdx } },
                        .{ .type = .f64, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_sd, .mov, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_q, .mov, .tmp3q, .tmp2x, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, .v_q, .mov, .tmp6q, .tmp1x, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp7q, .tmp5q, ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .cmp, .tmp7q, .tmp5q, ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, .v_q, .mov, .tmp2x, .tmp3q, ._, ._ },
                        .{ ._, .v_sd, .add, .tmp1x, .tmp1x, .tmp2q, ._ },
                        .{ .@"1:", .v_sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse2, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmod" } },
                        .{ .type = .f64, .kind = .{ .reg = .rcx } },
                        .{ .type = .f64, .kind = .{ .reg = .rdx } },
                        .{ .type = .f64, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._sd, .mov, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._q, .mov, .tmp3q, .tmp2x, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._q, .mov, .tmp6q, .tmp1x, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp7q, .tmp5q, ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .cmp, .tmp7q, .tmp5q, ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._q, .mov, .tmp2x, .tmp3q, ._, ._ },
                        .{ ._, ._sd, .add, .tmp1x, .tmp2q, ._, ._ },
                        .{ .@"1:", ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmod" } },
                        .{ .type = .f64, .kind = .{ .reg = .rdx } },
                        .{ .type = .f64, .kind = .mem },
                        .{ .type = .f64, .kind = .{ .reg = .rax } },
                        .{ .type = .f64, .kind = .{ .reg = .st7 } },
                        .{ .type = .f64, .kind = .{ .reg = .st6 } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._ps, .xor, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._ps, .movl, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._ps, .movl, .mem(.tmp5q), .tmp1x, ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp4q, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .mem(.tmp5q), ._, ._ },
                        .{ ._, ._, .cmp, .tmp6q, .tmp4q, ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, .f_, .ld, .mem(.tmp5q), ._, ._, ._ },
                        .{ ._, .f_, .add, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, .f_p, .st, .mem(.tmp5q), ._, ._, ._ },
                        .{ ._, ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._ps, .movl, .tmp1x, .mem(.tmp5q), ._, ._ },
                        .{ .@"1:", ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .@"64bit", .avx, .x87, .fast_imm16 },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .reg = .st0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, .v_dqa, .mov, .tmp0x, .mem(.src0x), ._, ._ },
                        .{ ._, .v_dqa, .mov, .mem(.tmp1x), .tmp0x, ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp0x, .mem(.src1x), ._, ._ },
                        .{ ._, .v_dqa, .mov, .memd(.tmp1x, 16), .tmp0x, ._, ._ },
                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .f_, .ld, .tmp3t, ._, ._, ._ },
                        .{ ._, .f_p, .st, .mem(.tmp1t), ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp5d, .memd(.src1w, 8), ._, ._ },
                        .{ ._, ._, .@"and", .tmp5w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp5w, .memd(.tmp1w, 8), ._, ._ },
                        .{ ._, ._, .cmp, .mem(.tmp1q), .si(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp5w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._nae, .j, .@"0f", ._, ._, ._ },
                        .{ ._, .f_, .ld, .mem(.src1t), ._, ._, ._ },
                        .{ ._, .f_p, .add, ._, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .in, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .@"64bit", .avx, .x87, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .reg = .st0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, .v_dqa, .mov, .tmp0x, .mem(.src0x), ._, ._ },
                        .{ ._, .v_dqa, .mov, .mem(.tmp1x), .tmp0x, ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp0x, .mem(.src1x), ._, ._ },
                        .{ ._, .v_dqa, .mov, .memd(.tmp1x, 16), .tmp0x, ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                        .{ ._, .f_, .ld, .tmp3t, ._, ._, ._ },
                        .{ ._, .f_p, .st, .mem(.tmp1t), ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .@"and", .tmp5w, .memd(.src1w, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp5w, .memd(.tmp1w, 8), ._, ._ },
                        .{ ._, ._, .cmp, .mem(.tmp1q), .si(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp5w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._nae, .j, .@"0f", ._, ._, ._ },
                        .{ ._, .f_, .ld, .mem(.src1t), ._, ._, ._ },
                        .{ ._, .f_p, .add, ._, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .in, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .@"64bit", .sse2, .x87, .fast_imm16 },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .reg = .st0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._dqa, .mov, .tmp0x, .mem(.src0x), ._, ._ },
                        .{ ._, ._dqa, .mov, .mem(.tmp1x), .tmp0x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp0x, .mem(.src1x), ._, ._ },
                        .{ ._, ._dqa, .mov, .memd(.tmp1x, 16), .tmp0x, ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                        .{ ._, .f_, .ld, .tmp3t, ._, ._, ._ },
                        .{ ._, .f_p, .st, .mem(.tmp1t), ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp5d, .memd(.src1w, 8), ._, ._ },
                        .{ ._, ._, .@"and", .tmp5w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp5w, .memd(.tmp1w, 8), ._, ._ },
                        .{ ._, ._, .cmp, .mem(.tmp1q), .si(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp5w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._nae, .j, .@"0f", ._, ._, ._ },
                        .{ ._, .f_, .ld, .mem(.src1t), ._, ._, ._ },
                        .{ ._, .f_p, .add, ._, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .in, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .@"64bit", .sse2, .x87, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .reg = .st0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._dqa, .mov, .tmp0x, .mem(.src0x), ._, ._ },
                        .{ ._, ._dqa, .mov, .mem(.tmp1x), .tmp0x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp0x, .mem(.src1x), ._, ._ },
                        .{ ._, ._dqa, .mov, .memd(.tmp1x, 16), .tmp0x, ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                        .{ ._, .f_, .ld, .tmp3t, ._, ._, ._ },
                        .{ ._, .f_p, .st, .mem(.tmp1t), ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .@"and", .tmp5w, .memd(.src1w, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp5w, .memd(.tmp1w, 8), ._, ._ },
                        .{ ._, ._, .cmp, .mem(.tmp1q), .si(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp5w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._nae, .j, .@"0f", ._, ._, ._ },
                        .{ ._, .f_, .ld, .mem(.src1t), ._, ._, ._ },
                        .{ ._, .f_p, .add, ._, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .in, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .@"64bit", .sse, .x87, .fast_imm16 },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .reg = .st0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._ps, .mova, .tmp0x, .mem(.src0x), ._, ._ },
                        .{ ._, ._ps, .mova, .mem(.tmp1x), .tmp0x, ._, ._ },
                        .{ ._, ._ps, .mova, .tmp0x, .mem(.src1x), ._, ._ },
                        .{ ._, ._ps, .mova, .memd(.tmp1x, 16), .tmp0x, ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                        .{ ._, .f_, .ld, .tmp3t, ._, ._, ._ },
                        .{ ._, .f_p, .st, .mem(.tmp1t), ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp5d, .memd(.src1w, 8), ._, ._ },
                        .{ ._, ._, .@"and", .tmp5w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp5w, .memd(.tmp1w, 8), ._, ._ },
                        .{ ._, ._, .cmp, .mem(.tmp1q), .si(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp5w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._nae, .j, .@"0f", ._, ._, ._ },
                        .{ ._, .f_, .ld, .memd(.src1t, 16), ._, ._, ._ },
                        .{ ._, .f_p, .add, ._, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .in, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .@"64bit", .sse, .x87, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .reg = .st0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._ps, .mova, .tmp0x, .mem(.src0x), ._, ._ },
                        .{ ._, ._ps, .mova, .mem(.tmp1x), .tmp0x, ._, ._ },
                        .{ ._, ._ps, .mova, .tmp0x, .mem(.src1x), ._, ._ },
                        .{ ._, ._ps, .mova, .memd(.tmp1x, 16), .tmp0x, ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                        .{ ._, .f_, .ld, .tmp3t, ._, ._, ._ },
                        .{ ._, .f_p, .st, .mem(.tmp1t), ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .@"and", .tmp5w, .memd(.src1w, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp5w, .memd(.tmp1w, 8), ._, ._ },
                        .{ ._, ._, .cmp, .mem(.tmp1q), .si(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp5w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._nae, .j, .@"0f", ._, ._, ._ },
                        .{ ._, .f_, .ld, .mem(.src1t), ._, ._, ._ },
                        .{ ._, .f_p, .add, ._, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .in, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_cc_abi = .win64,
                    .required_features = .{ .@"64bit", .x87, .fast_imm16, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .mem },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .reg = .st0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, .f_, .ld, .mem(.tmp0t), ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp7d, .memd(.src1w, 8), ._, ._ },
                        .{ ._, ._, .@"and", .tmp7w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp7w, .memd(.tmp0w, 8), ._, ._ },
                        .{ ._, ._, .cmp, .mem(.tmp0q), .si(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp7w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._nae, .j, .@"0f", ._, ._, ._ },
                        .{ ._, .f_, .ld, .mem(.src1t), ._, ._, ._ },
                        .{ ._, .f_p, .add, ._, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .in, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_cc_abi = .win64,
                    .required_features = .{ .@"64bit", .x87, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .mem },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .reg = .st0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, .f_, .ld, .mem(.tmp0t), ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp7d, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .@"and", .tmp7w, .memd(.src1w, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp7w, .memd(.tmp0w, 8), ._, ._ },
                        .{ ._, ._, .cmp, .mem(.tmp0q), .si(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp7w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._nae, .j, .@"0f", ._, ._, ._ },
                        .{ ._, .f_, .ld, .mem(.src1t), ._, ._, ._ },
                        .{ ._, .f_p, .add, ._, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .in, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .@"64bit", .avx, .x87, .fast_imm16 },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .memd(.tmp2x, 16), .tmp1x, ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                        .{ ._, .f_, .ld, .tmp4t, ._, ._, ._ },
                        .{ ._, .f_p, .st, .mem(.tmp2t), ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp6d, .memid(.src1w, .tmp0, 8), ._, ._ },
                        .{ ._, ._, .@"and", .tmp6w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp6w, .memd(.tmp2w, 8), ._, ._ },
                        .{ ._, ._, .cmp, .mem(.tmp2q), .si(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp6w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, .f_, .ld, .memi(.src1t, .tmp0), ._, ._, ._ },
                        .{ ._, .f_p, .add, ._, ._, ._, ._ },
                        .{ .@"1:", .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .@"64bit", .avx, .x87, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .memd(.tmp2x, 16), .tmp1x, ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                        .{ ._, .f_, .ld, .tmp4t, ._, ._, ._ },
                        .{ ._, .f_p, .st, .mem(.tmp2t), ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .@"and", .tmp6w, .memid(.src1w, .tmp0, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6w, .memd(.tmp2w, 8), ._, ._ },
                        .{ ._, ._, .cmp, .mem(.tmp2q), .si(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp6w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, .f_, .ld, .memi(.src1t, .tmp0), ._, ._, ._ },
                        .{ ._, .f_p, .add, ._, ._, ._, ._ },
                        .{ .@"1:", .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .@"64bit", .sse2, .x87, .fast_imm16 },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memd(.tmp2x, 16), .tmp1x, ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                        .{ ._, .f_, .ld, .tmp4t, ._, ._, ._ },
                        .{ ._, .f_p, .st, .mem(.tmp2t), ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp6d, .memid(.src1w, .tmp0, 8), ._, ._ },
                        .{ ._, ._, .@"and", .tmp6w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp6w, .memd(.tmp2w, 8), ._, ._ },
                        .{ ._, ._, .cmp, .mem(.tmp2q), .si(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp6w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, .f_, .ld, .memi(.src1t, .tmp0), ._, ._, ._ },
                        .{ ._, .f_p, .add, ._, ._, ._, ._ },
                        .{ .@"1:", .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .@"64bit", .sse2, .x87, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memd(.tmp2x, 16), .tmp1x, ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                        .{ ._, .f_, .ld, .tmp4t, ._, ._, ._ },
                        .{ ._, .f_p, .st, .mem(.tmp2t), ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .@"and", .tmp6w, .memid(.src1w, .tmp0, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6w, .memd(.tmp2w, 8), ._, ._ },
                        .{ ._, ._, .cmp, .mem(.tmp2q), .si(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp6w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, .f_, .ld, .memi(.src1t, .tmp0), ._, ._, ._ },
                        .{ ._, .f_p, .add, ._, ._, ._, ._ },
                        .{ .@"1:", .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .@"64bit", .sse, .x87, .fast_imm16 },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._ps, .mova, .mem(.tmp2x), .tmp1x, ._, ._ },
                        .{ ._, ._ps, .mova, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._ps, .mova, .memd(.tmp2x, 16), .tmp1x, ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                        .{ ._, .f_, .ld, .tmp4t, ._, ._, ._ },
                        .{ ._, .f_p, .st, .mem(.tmp2t), ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp6d, .memid(.src1w, .tmp0, 8), ._, ._ },
                        .{ ._, ._, .@"and", .tmp6w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp6w, .memd(.tmp2w, 8), ._, ._ },
                        .{ ._, ._, .cmp, .mem(.tmp2q), .si(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp6w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, .f_, .ld, .memi(.src1t, .tmp0), ._, ._, ._ },
                        .{ ._, .f_p, .add, ._, ._, ._, ._ },
                        .{ .@"1:", .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .@"64bit", .sse, .x87, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .size = 16 * 2, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._ps, .mova, .mem(.tmp2x), .tmp1x, ._, ._ },
                        .{ ._, ._ps, .mova, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._ps, .mova, .memd(.tmp2x, 16), .tmp1x, ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                        .{ ._, .f_, .ld, .tmp4t, ._, ._, ._ },
                        .{ ._, .f_p, .st, .mem(.tmp2t), ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .@"and", .tmp6w, .memid(.src1w, .tmp0, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6w, .memd(.tmp2w, 8), ._, ._ },
                        .{ ._, ._, .cmp, .mem(.tmp2q), .si(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp6w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, .f_, .ld, .memi(.src1t, .tmp0), ._, ._, ._ },
                        .{ ._, .f_p, .add, ._, ._, ._, ._ },
                        .{ .@"1:", .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_cc_abi = .win64,
                    .required_features = .{ .@"64bit", .sse, .x87, .fast_imm16 },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                        .{ .type = .f80, .kind = .{ .reg = .rax } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.dst0, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .memi(.src1, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp5d, .memid(.src1w, .tmp0, 8), ._, ._ },
                        .{ ._, ._, .@"and", .tmp5w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .tmp5w, .memd(.tmp2w, 8), ._, ._ },
                        .{ ._, ._, .cmp, .mem(.tmp2q), .si(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp5w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, .f_, .ld, .memi(.src1t, .tmp0), ._, ._, ._ },
                        .{ ._, .f_, .ld, .memi(.dst0t, .tmp0), ._, ._, ._ },
                        .{ ._, .f_p, .add, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .memi(.dst0t, .tmp0), ._, ._, ._ },
                        .{ .@"1:", ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_cc_abi = .win64,
                    .required_features = .{ .@"64bit", .sse, .x87, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } },
                        .{ .type = .f80, .kind = .{ .reg = .rax } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.dst0, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .memi(.src1, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .@"and", .tmp5w, .memid(.src1w, .tmp0, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp5w, .memd(.tmp2w, 8), ._, ._ },
                        .{ ._, ._, .cmp, .mem(.tmp2q), .si(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp5w, .sa(.src0, .add_smin), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, .f_, .ld, .memi(.src1t, .tmp0), ._, ._, ._ },
                        .{ ._, .f_, .ld, .memi(.dst0t, .tmp0), ._, ._, ._ },
                        .{ ._, .f_p, .add, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .memi(.dst0t, .tmp0), ._, ._, ._ },
                        .{ .@"1:", ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f128, .kind = .mem },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmodq" } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, .v_dqa, .mov, .mem(.tmp0x), .src1x, ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, .vp_q, .extr, .tmp3q, .dst0x, .ui(1), ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp4q, .memd(.tmp0q, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4q, .tmp3q, ._, ._ },
                        .{ ._, .v_q, .mov, .tmp3q, .dst0x, ._, ._ },
                        .{ ._, ._, .cmp, .tmp3q, .si(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._nae, .j, .@"0f", ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .src1x, .mem(.tmp0x), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .@"64bit", .sse4_1, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f128, .kind = .mem },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmodq" } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._dqa, .mov, .mem(.tmp0x), .src1x, ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, .p_q, .extr, .tmp3q, .dst0x, .ui(1), ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp4q, .memd(.tmp0q, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4q, .tmp3q, ._, ._ },
                        .{ ._, ._q, .mov, .tmp3q, .dst0x, ._, ._ },
                        .{ ._, ._, .cmp, .tmp3q, .si(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._nae, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .src1x, .mem(.tmp0x), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .@"64bit", .sse2, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f128, .kind = .mem },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmodq" } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._dqa, .mov, .mem(.tmp0x), .src1x, ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                        .{ ._, .p_d, .shuf, .src1x, .dst0x, .ui(0b11_10_11_10), ._ },
                        .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._q, .mov, .tmp3q, .src1x, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp4q, .memd(.tmp0q, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4q, .tmp3q, ._, ._ },
                        .{ ._, ._q, .mov, .tmp3q, .dst0x, ._, ._ },
                        .{ ._, ._, .cmp, .tmp3q, .si(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._nae, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .src1x, .mem(.tmp0x), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f128, .kind = .mem },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmodq" } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .f128, .kind = .mem },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._ps, .mova, .mem(.tmp0x), .src1x, ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._ps, .mova, .mem(.tmp3x), .dst0x, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp4q, .memd(.tmp0q, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4q, .memd(.tmp3q, 8), ._, ._ },
                        .{ ._, ._, .cmp, .mem(.tmp3q), .si(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._nae, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._ps, .mova, .src1x, .mem(.tmp0x), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmodq" } },
                        .{ .type = .f128, .kind = .mem },
                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, .vp_q, .extr, .tmp1q, .dst0x, .ui(1), ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp0q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp5q, .memd(.src1q, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp1q, ._, ._ },
                        .{ ._, .v_q, .mov, .tmp1q, .dst0x, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1q, .si(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp5q, .tmp0q, ._, ._ },
                        .{ ._, ._nae, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                        .{ ._, .v_dqa, .mov, .lea(.tmp0x), .dst0x, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .@"64bit", .sse4_1, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmodq" } },
                        .{ .type = .f128, .kind = .mem },
                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, .p_q, .extr, .tmp1q, .dst0x, .ui(1), ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp0q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp5q, .memd(.src1q, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp1q, ._, ._ },
                        .{ ._, ._q, .mov, .tmp1q, .dst0x, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1q, .si(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp5q, .tmp0q, ._, ._ },
                        .{ ._, ._nae, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                        .{ ._, ._dqa, .mov, .lea(.tmp0x), .dst0x, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .@"64bit", .sse2, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmodq" } },
                        .{ .type = .f128, .kind = .mem },
                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_d, .shuf, .tmp4x, .dst0x, .ui(0b11_10_11_10), ._ },
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._q, .mov, .tmp1q, .tmp4x, ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp0q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp5q, .memd(.src1q, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp1q, ._, ._ },
                        .{ ._, ._q, .mov, .tmp1q, .dst0x, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1q, .si(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp5q, .tmp0q, ._, ._ },
                        .{ ._, ._nae, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                        .{ ._, ._dqa, .mov, .lea(.tmp0x), .dst0x, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmodq" } },
                        .{ .type = .f128, .kind = .mem },
                        .{ .type = .usize, .kind = .{ .reg = .rax } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._ps, .mova, .lea(.tmp0x), .dst0x, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp1q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp4q, .memd(.src1q, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4q, .lead(.tmp0q, 8), ._, ._ },
                        .{ ._, ._, .cmp, .lea(.tmp0q), .si(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp4q, .tmp1q, ._, ._ },
                        .{ ._, ._nae, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmodq" } },
                        .{ .type = .f128, .kind = .{ .reg = .rcx } },
                        .{ .type = .f128, .kind = .{ .reg = .rdx } },
                        .{ .type = .f128, .kind = .{ .reg = .rax } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, .vp_q, .extr, .tmp5q, .tmp1x, .ui(1), ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp4q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .memiad(.src1q, .tmp0, .add_unaligned_size, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp5q, ._, ._ },
                        .{ ._, .v_q, .mov, .tmp5q, .tmp1x, ._, ._ },
                        .{ ._, ._, .cmp, .tmp5q, .si(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp6q, .tmp4q, ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .call, .tmp7d, ._, ._, ._ },
                        .{ .@"1:", .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .@"64bit", .sse4_1, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmodq" } },
                        .{ .type = .f128, .kind = .{ .reg = .rcx } },
                        .{ .type = .f128, .kind = .{ .reg = .rdx } },
                        .{ .type = .f128, .kind = .{ .reg = .rax } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, .p_q, .extr, .tmp5q, .tmp1x, .ui(1), ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp4q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .memiad(.src1q, .tmp0, .add_unaligned_size, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp5q, ._, ._ },
                        .{ ._, ._q, .mov, .tmp5q, .tmp1x, ._, ._ },
                        .{ ._, ._, .cmp, .tmp5q, .si(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp6q, .tmp4q, ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .call, .tmp7d, ._, ._, ._ },
                        .{ .@"1:", ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .@"64bit", .sse2, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmodq" } },
                        .{ .type = .f128, .kind = .{ .reg = .rcx } },
                        .{ .type = .f128, .kind = .{ .reg = .rdx } },
                        .{ .type = .f128, .kind = .{ .reg = .rax } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, .p_d, .shuf, .tmp2x, .tmp1x, .ui(0b11_10_11_10), ._ },
                        .{ ._, ._q, .mov, .tmp5q, .tmp2x, ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp4q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .memiad(.src1q, .tmp0, .add_unaligned_size, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp5q, ._, ._ },
                        .{ ._, ._q, .mov, .tmp5q, .tmp1x, ._, ._ },
                        .{ ._, ._, .cmp, .tmp5q, .si(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp6q, .tmp4q, ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .call, .tmp7d, ._, ._, ._ },
                        .{ .@"1:", ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmodq" } },
                        .{ .type = .f128, .kind = .{ .reg = .rdx } },
                        .{ .type = .f128, .kind = .mem },
                        .{ .type = .f128, .kind = .{ .reg = .rax } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._ps, .mova, .mem(.tmp5x), .tmp1x, ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp4q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .memiad(.src1q, .tmp0, .add_unaligned_size, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .memd(.tmp5q, 8), ._, ._ },
                        .{ ._, ._, .cmp, .mem(.tmp5q), .si(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp6q, .tmp4q, ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .call, .tmp7d, ._, ._, ._ },
                        .{ .@"1:", ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f} {f}", .{
                        @tagName(air_tag),
                        cg.typeOf(bin_op.lhs).fmt(pt),
                        ops[0].tracking(cg),
                        ops[1].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
            },
            .ptr_add => |air_tag| {
                const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
                const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data;
                var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                try ops[0].toSlicePtr(cg);
                var res: [1]Temp = undefined;
                if (!hack_around_sema_opv_bugs or ty_pl.ty.toType().elemType2(zcu).hasRuntimeBitsIgnoreComptime(zcu)) cg.select(&res, &.{ty_pl.ty.toType()}, &ops, comptime &.{ .{
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .simm32, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p, .leaa(.src0, .add_src0_elem_size_mul_src1), ._, ._ },
                    } },
                }, .{
                    .dst_constraints = .{ .{ .elem_size_is = 1 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p, .leai(.src0, .src1), ._, ._ },
                    } },
                }, .{
                    .dst_constraints = .{ .{ .elem_size_is = 2 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p, .leasi(.src0, .@"2", .src1), ._, ._ },
                    } },
                }, .{
                    .dst_constraints = .{ .{ .elem_size_is = 2 + 1 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p, .leasi(.src1, .@"2", .src1), ._, ._ },
                        .{ ._, ._, .lea, .dst0p, .leai(.src0, .dst0), ._, ._ },
                    } },
                }, .{
                    .dst_constraints = .{ .{ .elem_size_is = 4 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p, .leasi(.src0, .@"4", .src1), ._, ._ },
                    } },
                }, .{
                    .dst_constraints = .{ .{ .elem_size_is = 4 + 1 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p, .leasi(.src1, .@"4", .src1), ._, ._ },
                        .{ ._, ._, .lea, .dst0p, .leai(.src0, .dst0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .dst_constraints = .{ .{ .elem_size_is = 8 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p, .leasi(.src0, .@"8", .src1), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .dst_constraints = .{ .{ .elem_size_is = 8 + 1 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p, .leasi(.src1, .@"8", .src1), ._, ._ },
                        .{ ._, ._, .lea, .dst0p, .leai(.src0, .dst0), ._, ._ },
                    } },
                }, .{
                    .dst_constraints = .{ .po2_elem_size, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_mut_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src1 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._l, .sh, .src1p, .sa(.none, .add_log2_src0_elem_size), ._, ._ },
                        .{ ._, ._, .lea, .dst0p, .leai(.src0, .src1), ._, ._ },
                    } },
                }, .{
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .i_, .mul, .dst0p, .src1p, .sa(.none, .add_src0_elem_size), ._ },
                        .{ ._, ._, .lea, .dst0p, .leai(.src0, .dst0), ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f} {f}", .{
                        @tagName(air_tag),
                        cg.typeOf(bin_op.lhs).fmt(pt),
                        ops[0].tracking(cg),
                        ops[1].tracking(cg),
                    }),
                    else => |e| return e,
                } else res[0] = ops[0];
                try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
            },
            .ptr_sub => |air_tag| {
                const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
                const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data;
                var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                try ops[0].toSlicePtr(cg);
                var res: [1]Temp = undefined;
                if (!hack_around_sema_opv_bugs or ty_pl.ty.toType().elemType2(zcu).hasRuntimeBitsIgnoreComptime(zcu)) cg.select(&res, &.{ty_pl.ty.toType()}, &ops, comptime &.{ .{
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .simm32, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p, .leaa(.src0, .sub_src0_elem_size_mul_src1), ._, ._ },
                    } },
                }, .{
                    .dst_constraints = .{ .{ .elem_size_is = 1 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_mut_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src1 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .neg, .src1p, ._, ._, ._ },
                        .{ ._, ._, .lea, .dst0p, .leai(.src0, .src1), ._, ._ },
                    } },
                }, .{
                    .dst_constraints = .{ .{ .elem_size_is = 2 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_mut_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src1 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .neg, .src1p, ._, ._, ._ },
                        .{ ._, ._, .lea, .dst0p, .leasi(.src0, .@"2", .src1), ._, ._ },
                    } },
                }, .{
                    .dst_constraints = .{ .{ .elem_size_is = 2 + 1 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p, .leasi(.src1, .@"2", .src1), ._, ._ },
                        .{ ._, ._, .neg, .dst0p, ._, ._, ._ },
                        .{ ._, ._, .lea, .dst0p, .leai(.src0, .dst0), ._, ._ },
                    } },
                }, .{
                    .dst_constraints = .{ .{ .elem_size_is = 4 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_mut_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src1 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .neg, .src1p, ._, ._, ._ },
                        .{ ._, ._, .lea, .dst0p, .leasi(.src0, .@"4", .src1), ._, ._ },
                    } },
                }, .{
                    .dst_constraints = .{ .{ .elem_size_is = 4 + 1 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p, .leasi(.src1, .@"4", .src1), ._, ._ },
                        .{ ._, ._, .neg, .dst0p, ._, ._, ._ },
                        .{ ._, ._, .lea, .dst0p, .leai(.src0, .dst0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .dst_constraints = .{ .{ .elem_size_is = 8 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_mut_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src1 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .neg, .src1p, ._, ._, ._ },
                        .{ ._, ._, .lea, .dst0p, .leasi(.src0, .@"8", .src1), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .dst_constraints = .{ .{ .elem_size_is = 8 + 1 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p, .leasi(.src1, .@"8", .src1), ._, ._ },
                        .{ ._, ._, .neg, .dst0p, ._, ._, ._ },
                        .{ ._, ._, .lea, .dst0p, .leai(.src0, .dst0), ._, ._ },
                    } },
                }, .{
                    .dst_constraints = .{ .po2_elem_size, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_mut_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src1 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._l, .sa, .src1p, .sa(.none, .add_log2_src0_elem_size), ._, ._ },
                        .{ ._, ._, .neg, .src1p, ._, ._, ._ },
                        .{ ._, ._, .lea, .dst0p, .leai(.src0, .src1), ._, ._ },
                    } },
                }, .{
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .i_, .mul, .dst0p, .src1p, .sa(.none, .sub_src0_elem_size), ._ },
                        .{ ._, ._, .lea, .dst0p, .leai(.src0, .dst0), ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f} {f}", .{
                        @tagName(air_tag),
                        cg.typeOf(bin_op.lhs).fmt(pt),
                        ops[0].tracking(cg),
                        ops[1].tracking(cg),
                    }),
                    else => |e| return e,
                } else res[0] = ops[0];
                try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
            },
            .max => |air_tag| {
                const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                var res: [1]Temp = undefined;
                cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ },
                        .{ ._, ._l, .cmov, .dst0d, .src1d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ },
                        .{ ._, ._nl, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0b, .src1b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ },
                        .{ ._, ._b, .cmov, .dst0d, .src1d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ },
                        .{ ._, ._nb, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0b, .src1b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ },
                        .{ ._, ._l, .cmov, .dst0w, .src1w, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ },
                        .{ ._, ._nl, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0w, .src1w, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ },
                        .{ ._, ._b, .cmov, .dst0w, .src1w, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ },
                        .{ ._, ._nb, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0w, .src1w, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ },
                        .{ ._, ._l, .cmov, .dst0d, .src1d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ },
                        .{ ._, ._nl, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .src1d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ },
                        .{ ._, ._b, .cmov, .dst0d, .src1d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ },
                        .{ ._, ._nb, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .src1d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ },
                        .{ ._, ._l, .cmov, .dst0q, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ },
                        .{ ._, ._nl, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0q, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ },
                        .{ ._, ._b, .cmov, .dst0q, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ },
                        .{ ._, ._nb, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0q, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{ .any_signed_int, .any_signed_int, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rsi } },
                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                        .{ ._, ._l, .cmov, .tmp0p, .tmp1p, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .any_signed_int, .any_signed_int, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rsi } },
                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._nl, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.src1), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{ .any_unsigned_int, .any_unsigned_int, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rsi } },
                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memsia(.src1q, .@"8", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                        .{ ._, ._b, .cmov, .tmp0p, .tmp1p, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .any_unsigned_int, .any_unsigned_int, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rsi } },
                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memsia(.src1q, .@"8", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._nb, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.src1), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_b, .maxs, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_b, .maxs, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._dqa, .mov, .dst0x, .src0x, ._, ._ },
                        .{ ._, .p_b, .cmpgt, .dst0x, .src1x, ._, ._ },
                        .{ ._, .p_, .@"and", .src0x, .dst0x, ._, ._ },
                        .{ ._, .p_, .andn, .dst0x, .src1x, ._, ._ },
                        .{ ._, .p_, .@"or", .dst0x, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .yword, .is = .byte } },
                        .{ .scalar_signed_int = .{ .of = .yword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_b, .maxs, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                        .{ ._, .vp_b, .maxs, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .vp_b, .maxs, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .p_b, .maxs, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ },
                        .{ ._, .p_b, .cmpgt, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .p_, .@"and", .tmp2x, .tmp1x, ._, ._ },
                        .{ ._, .p_, .andn, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .p_, .@"or", .tmp1x, .tmp2x, ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .movsx, .tmp2d, .memia(.src1b, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp2b, ._, ._ },
                        .{ ._, ._l, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .movsx, .tmp2d, .memia(.src1b, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp2b, ._, ._ },
                        .{ ._, ._l, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .memia(.src1b, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._nl, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1b, .memia(.src1b, .tmp0, .add_size), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .memia(.src1b, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._nl, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1b, .memia(.src1b, .tmp0, .add_size), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, .mmx, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } },
                        .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_mmx, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_mmx, .to_mmx, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_b, .maxu, .dst0q, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_b, .maxu, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_b, .maxu, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .yword, .is = .byte } },
                        .{ .scalar_unsigned_int = .{ .of = .yword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_b, .maxu, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                        .{ ._, .vp_b, .maxu, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .vp_b, .maxu, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .p_b, .maxu, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .movzx, .tmp2d, .memia(.src1b, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp2b, ._, ._ },
                        .{ ._, ._b, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .movzx, .tmp2d, .memia(.src1b, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp2b, ._, ._ },
                        .{ ._, ._b, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .memia(.src1b, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._nb, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1b, .memia(.src1b, .tmp0, .add_size), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .memia(.src1b, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._nb, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1b, .memia(.src1b, .tmp0, .add_size), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, .mmx, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .qword, .is = .word } },
                        .{ .scalar_signed_int = .{ .of = .qword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_mmx, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_mmx, .to_mmx, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_w, .maxs, .dst0q, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .word } },
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .maxs, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .word } },
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_w, .maxs, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .yword, .is = .word } },
                        .{ .scalar_signed_int = .{ .of = .yword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .maxs, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } },
                        .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                        .{ ._, .vp_w, .maxs, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } },
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .vp_w, .maxs, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } },
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .p_w, .maxs, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1w, .memia(.src1w, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._l, .cmov, .tmp1w, .memia(.src1w, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1w, .memia(.src1w, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._nl, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1w, .memia(.src1w, .tmp0, .add_size), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .maxu, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_w, .maxu, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_w, .subus, .dst0x, .src1x, ._, ._ },
                        .{ ._, .p_w, .add, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .yword, .is = .word } },
                        .{ .scalar_unsigned_int = .{ .of = .yword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .maxu, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .word } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                        .{ ._, .vp_w, .maxu, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .vp_w, .maxu, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .p_w, .maxu, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .p_w, .subus, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .p_w, .add, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1w, .memia(.src1w, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._b, .cmov, .tmp1w, .memia(.src1w, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1w, .memia(.src1w, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._nb, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1w, .memia(.src1w, .tmp0, .add_size), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .maxs, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_d, .maxs, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_or_exclusive_int = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_signed_or_exclusive_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._dqa, .mov, .dst0x, .src0x, ._, ._ },
                        .{ ._, .p_d, .cmpgt, .dst0x, .src1x, ._, ._ },
                        .{ ._, .p_, .@"and", .src0x, .dst0x, ._, ._ },
                        .{ ._, .p_, .andn, .dst0x, .src1x, ._, ._ },
                        .{ ._, .p_, .@"or", .dst0x, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .yword, .is = .dword } },
                        .{ .scalar_signed_int = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .maxs, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                        .{ ._, .vp_d, .maxs, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .vp_d, .maxs, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .p_d, .maxs, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_or_exclusive_int = .{ .of = .xword, .is = .dword } },
                        .{ .multiple_scalar_signed_or_exclusive_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ },
                        .{ ._, .p_d, .cmpgt, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .p_, .@"and", .tmp2x, .tmp1x, ._, ._ },
                        .{ ._, .p_, .andn, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .p_, .@"or", .tmp1x, .tmp2x, ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._l, .cmov, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._nl, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0d, .tmp0, .add_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .maxu, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_d, .maxu, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 32 } },
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 32 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u32, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
                        .{ ._, .p_, .xor, .dst0x, .src0x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .src1x, ._, ._ },
                        .{ ._, .p_d, .cmpgt, .dst0x, .tmp2x, ._, ._ },
                        .{ ._, .p_, .@"and", .src0x, .dst0x, ._, ._ },
                        .{ ._, .p_, .andn, .dst0x, .src1x, ._, ._ },
                        .{ ._, .p_, .@"or", .dst0x, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .yword, .is = .dword } },
                        .{ .scalar_unsigned_int = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .maxu, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                        .{ ._, .vp_d, .maxu, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .vp_d, .maxu, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .p_d, .maxu, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 32 } },
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 32 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u32, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp5x, .tmp3x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp6x, .tmp4x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp5x, .tmp2x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp6x, .tmp2x, ._, ._ },
                        .{ ._, .p_d, .cmpgt, .tmp5x, .tmp6x, ._, ._ },
                        .{ ._, .p_, .@"and", .tmp3x, .tmp5x, ._, ._ },
                        .{ ._, .p_, .andn, .tmp5x, .tmp4x, ._, ._ },
                        .{ ._, .p_, .@"or", .tmp3x, .tmp5x, ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._b, .cmov, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._nb, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0d, .tmp0, .add_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_or_exclusive_int = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_signed_or_exclusive_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_q, .cmpgt, .dst0x, .src1x, .src0x, ._ },
                        .{ ._, .vp_b, .blendv, .dst0x, .src0x, .src1x, .dst0x },
                    } },
                }, .{
                    .required_features = .{ .sse4_2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_or_exclusive_int = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_signed_or_exclusive_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._dqa, .mov, .tmp0x, .src1x, ._, ._ },
                        .{ ._, .p_q, .cmpgt, .tmp0x, .src0x, ._, ._ },
                        .{ ._, .p_b, .blendv, .dst0x, .src1x, .tmp0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_or_exclusive_int = .{ .of = .yword, .is = .qword } },
                        .{ .scalar_signed_or_exclusive_int = .{ .of = .yword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_q, .cmpgt, .dst0y, .src1y, .src0y, ._ },
                        .{ ._, .vp_b, .blendv, .dst0y, .src0y, .src1y, .dst0y },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_or_exclusive_int = .{ .of = .yword, .is = .qword } },
                        .{ .multiple_scalar_signed_or_exclusive_int = .{ .of = .yword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp2y, .memia(.src1y, .tmp0, .add_size), ._, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp3y, .tmp2y, .tmp1y, ._ },
                        .{ ._, .vp_b, .blendv, .tmp1y, .tmp1y, .tmp2y, .tmp3y },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_or_exclusive_int = .{ .of = .xword, .is = .qword } },
                        .{ .multiple_scalar_signed_or_exclusive_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp3x, .tmp2x, .tmp1x, ._ },
                        .{ ._, .vp_b, .blendv, .tmp1x, .tmp1x, .tmp2x, .tmp3x },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_or_exclusive_int = .{ .of = .xword, .is = .qword } },
                        .{ .multiple_scalar_signed_or_exclusive_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, .p_q, .cmpgt, .tmp3x, .tmp1x, ._, ._ },
                        .{ ._, .p_b, .blendv, .tmp1x, .tmp2x, .tmp3x, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._l, .cmov, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._nl, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, .vp_, .xor, .dst0x, .tmp2x, .src0x, ._ },
                        .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .src1x, ._ },
                        .{ ._, .vp_q, .cmpgt, .dst0x, .tmp2x, .dst0x, ._ },
                        .{ ._, .vp_b, .blendv, .dst0x, .src0x, .src1x, .dst0x },
                    } },
                }, .{
                    .required_features = .{ .sse4_2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .reg = .xmm0 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .src0x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp3x, .src1x, ._, ._ },
                        .{ ._, .p_q, .cmpgt, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, .p_b, .blendv, .dst0x, .src1x, .tmp3x, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_unsigned_int = .{ .of = .yword, .is = 64 } },
                        .{ .scalar_exact_unsigned_int = .{ .of = .yword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ },
                        .{ ._, .vp_, .xor, .dst0y, .tmp2y, .src0y, ._ },
                        .{ ._, .vp_, .xor, .tmp2y, .tmp2y, .src1y, ._ },
                        .{ ._, .vp_q, .cmpgt, .dst0y, .tmp2y, .dst0y, ._ },
                        .{ ._, .vp_b, .blendv, .dst0y, .src0y, .src1y, .dst0y },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .yword, .is = 64 } },
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .yword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp4y, .memia(.src1y, .tmp0, .add_size), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp5y, .tmp3y, .tmp2y, ._ },
                        .{ ._, .vp_, .xor, .tmp6y, .tmp4y, .tmp2y, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp5y, .tmp6y, .tmp5y, ._ },
                        .{ ._, .vp_b, .blendv, .tmp3y, .tmp3y, .tmp4y, .tmp5y },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp3y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp5x, .tmp3x, .tmp2x, ._ },
                        .{ ._, .vp_, .xor, .tmp6x, .tmp4x, .tmp2x, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp5x, .tmp6x, .tmp5x, ._ },
                        .{ ._, .vp_b, .blendv, .tmp3x, .tmp3x, .tmp4x, .tmp5x },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .reg = .xmm0 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp5x, .tmp2x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp6x, .tmp2x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .p_, .xor, .tmp5x, .tmp3x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp6x, .tmp4x, ._, ._ },
                        .{ ._, .p_q, .cmpgt, .tmp6x, .tmp5x, ._, ._ },
                        .{ ._, .p_b, .blendv, .tmp3x, .tmp4x, .tmp6x, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._b, .cmov, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._nb, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{ .any_scalar_signed_int, .any_scalar_signed_int, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .reg = .rsi } },
                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .sia(-1, .none, .add_src0_elem_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sbb, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sbb, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memiad(.src0, .tmp0, .add_unaligned_size_sub_elem_size, 8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memiad(.src1, .tmp0, .add_unaligned_size_sub_elem_size, 8), ._, ._ },
                        .{ ._, ._l, .cmov, .tmp1p, .tmp2p, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memiad(.dst0, .tmp0, .add_unaligned_size_sub_elem_size, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.none, .add_src0_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .any_scalar_signed_int, .any_scalar_signed_int, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .reg = .rsi } },
                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .sia(-1, .none, .add_src0_elem_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sbb, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sbb, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memiad(.src0, .tmp0, .add_unaligned_size_sub_elem_size, 8), ._, ._ },
                        .{ ._, ._nl, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memiad(.src1, .tmp0, .add_unaligned_size_sub_elem_size, 8), ._, ._ },
                        .{ .@"1:", ._, .lea, .tmp2p, .memiad(.dst0, .tmp0, .add_unaligned_size_sub_elem_size, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.none, .add_src0_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{ .any_scalar_unsigned_int, .any_scalar_unsigned_int, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .reg = .rsi } },
                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .sa(.none, .add_src0_elem_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sbb, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memia(.src1, .tmp0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ ._, ._b, .cmov, .tmp1p, .tmp2p, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memia(.dst0, .tmp0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.none, .add_src0_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._, .@"test", .tmp0p, .tmp0p, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .any_scalar_unsigned_int, .any_scalar_unsigned_int, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .reg = .rsi } },
                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .sa(.none, .add_src0_elem_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sbb, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ ._, ._nb, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memia(.src1, .tmp0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ .@"1:", ._, .lea, .tmp2p, .memia(.dst0, .tmp0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.none, .add_src0_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._, .@"test", .tmp0p, .tmp0p, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .{ .type = .f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
                        .{ ._, .v_ss, .cmp, .tmp1x, .dst0d, .dst0x, .vp(.unord) },
                        .{ ._, .v_ss, .max, .dst0x, .tmp0d, .dst0x, ._ },
                        .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp0x, .tmp1x },
                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmaxh" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .word } },
                        .{ .scalar_float = .{ .of = .qword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_4_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
                        .{ ._, .v_ps, .cmp, .tmp1x, .dst0x, .dst0x, .vp(.unord) },
                        .{ ._, .v_ps, .max, .dst0x, .tmp0x, .dst0x, ._ },
                        .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp0x, .tmp1x },
                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .word } },
                        .{ .scalar_float = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ },
                        .{ ._, .v_ps, .cmp, .tmp1y, .dst0y, .dst0y, .vp(.unord) },
                        .{ ._, .v_ps, .max, .dst0y, .tmp0y, .dst0y, ._ },
                        .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp0y, .tmp1y },
                        .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .v_ps, .cmp, .tmp3y, .tmp1y, .tmp1y, .vp(.unord) },
                        .{ ._, .v_ps, .max, .tmp1y, .tmp2y, .tmp1y, ._ },
                        .{ ._, .v_ps, .blendv, .tmp1y, .tmp1y, .tmp2y, .tmp3y },
                        .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_size), .tmp1y, .rm(.{}), ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmaxh" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ },
                        .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memia(.src0w, .tmp0, .add_size), .ui(0) },
                        .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memia(.src1w, .tmp0, .add_size), .ui(0) },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_size), .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmaxh" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_size), .ui(0), ._ },
                        .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_size), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_size), .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmaxh" } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_size), .ui(0), ._ },
                        .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_size), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .tmp4d, .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_size), .tmp4w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmaxh" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ss, .cmp, .tmp0x, .src0x, .src0d, .vp(.unord) },
                        .{ ._, .v_ss, .max, .dst0x, .src1x, .src0d, ._ },
                        .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .src1x, .tmp0x },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._ps, .mova, .dst0x, .src1x, ._, ._ },
                        .{ ._, ._ss, .max, .dst0x, .src0d, ._, ._ },
                        .{ ._, ._ss, .cmp, .src0x, .src0d, .sp(.unord), ._ },
                        .{ ._, ._ps, .blendv, .dst0x, .src1x, .src0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._ps, .mova, .tmp0x, .src1x, ._, ._ },
                        .{ ._, ._ss, .max, .tmp0x, .src0d, ._, ._ },
                        .{ ._, ._ss, .cmp, .dst0x, .src0d, .sp(.ord), ._ },
                        .{ ._, ._ps, .@"and", .tmp0x, .dst0x, ._, ._ },
                        .{ ._, ._ps, .andn, .dst0x, .src1x, ._, ._ },
                        .{ ._, ._ps, .@"or", .dst0x, .tmp0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cmp, .tmp0x, .src0x, .src0x, .vp(.unord) },
                        .{ ._, .v_ps, .max, .dst0x, .src1x, .src0x, ._ },
                        .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .src1x, .tmp0x },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .xmm0 }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .xmm0 }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._ps, .mova, .dst0x, .src1x, ._, ._ },
                        .{ ._, ._ps, .max, .dst0x, .src0x, ._, ._ },
                        .{ ._, ._ps, .cmp, .src0x, .src0x, .sp(.unord), ._ },
                        .{ ._, ._ps, .blendv, .dst0x, .src1x, .src0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._ps, .mova, .tmp0x, .src1x, ._, ._ },
                        .{ ._, ._ps, .max, .tmp0x, .src0x, ._, ._ },
                        .{ ._, ._ps, .cmp, .dst0x, .src0x, .sp(.ord), ._ },
                        .{ ._, ._ps, .@"and", .tmp0x, .dst0x, ._, ._ },
                        .{ ._, ._ps, .andn, .dst0x, .src1x, ._, ._ },
                        .{ ._, ._ps, .@"or", .dst0x, .tmp0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .yword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cmp, .tmp0y, .src0y, .src0y, .vp(.unord) },
                        .{ ._, .v_ps, .max, .dst0y, .src1y, .src0y, ._ },
                        .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .src1y, .tmp0y },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_ps, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                        .{ ._, .v_ps, .mova, .tmp2y, .memia(.src1y, .tmp0, .add_size), ._, ._ },
                        .{ ._, .v_ps, .cmp, .tmp3y, .tmp1y, .tmp1y, .vp(.unord) },
                        .{ ._, .v_ps, .max, .tmp1y, .tmp2y, .tmp1y, ._ },
                        .{ ._, .v_ps, .blendv, .tmp1y, .tmp1y, .tmp2y, .tmp3y },
                        .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_f32, .kind = .{ .reg = .xmm0 } },
                        .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._ps, .mova, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, ._ps, .max, .tmp3x, .tmp1x, ._, ._ },
                        .{ ._, ._ps, .cmp, .tmp1x, .tmp1x, .sp(.unord), ._ },
                        .{ ._, ._ps, .blendv, .tmp3x, .tmp2x, .tmp1x, ._ },
                        .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._ps, .mova, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, ._ps, .max, .tmp3x, .tmp1x, ._, ._ },
                        .{ ._, ._ps, .cmp, .tmp1x, .tmp1x, .sp(.ord), ._ },
                        .{ ._, ._ps, .@"and", .tmp3x, .tmp1x, ._, ._ },
                        .{ ._, ._ps, .andn, .tmp1x, .tmp2x, ._, ._ },
                        .{ ._, ._ps, .@"or", .tmp1x, .tmp3x, ._, ._ },
                        .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_sd, .cmp, .tmp0x, .src0x, .src0q, .vp(.unord) },
                        .{ ._, .v_sd, .max, .dst0x, .src1x, .src0q, ._ },
                        .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .src1x, .tmp0x },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._pd, .mova, .dst0x, .src1x, ._, ._ },
                        .{ ._, ._sd, .max, .dst0x, .src0q, ._, ._ },
                        .{ ._, ._sd, .cmp, .src0x, .src0q, .sp(.unord), ._ },
                        .{ ._, ._pd, .blendv, .dst0x, .src1x, .src0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._pd, .mova, .tmp0x, .src1x, ._, ._ },
                        .{ ._, ._sd, .max, .tmp0x, .src0q, ._, ._ },
                        .{ ._, ._sd, .cmp, .dst0x, .src0q, .sp(.ord), ._ },
                        .{ ._, ._pd, .@"and", .tmp0x, .dst0x, ._, ._ },
                        .{ ._, ._pd, .andn, .dst0x, .src1x, ._, ._ },
                        .{ ._, ._pd, .@"or", .dst0x, .tmp0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "fmax" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_pd, .cmp, .tmp0x, .src0x, .src0x, .vp(.unord) },
                        .{ ._, .v_pd, .max, .dst0x, .src1x, .src0x, ._ },
                        .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .src1x, .tmp0x },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .xmm0 }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .xmm0 }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._pd, .mova, .dst0x, .src1x, ._, ._ },
                        .{ ._, ._pd, .max, .dst0x, .src0x, ._, ._ },
                        .{ ._, ._pd, .cmp, .src0x, .src0x, .sp(.unord), ._ },
                        .{ ._, ._pd, .blendv, .dst0x, .src1x, .src0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._pd, .mova, .tmp0x, .src1x, ._, ._ },
                        .{ ._, ._pd, .max, .tmp0x, .src0x, ._, ._ },
                        .{ ._, ._pd, .cmp, .dst0x, .src0x, .sp(.ord), ._ },
                        .{ ._, ._pd, .@"and", .tmp0x, .dst0x, ._, ._ },
                        .{ ._, ._pd, .andn, .dst0x, .src1x, ._, ._ },
                        .{ ._, ._pd, .@"or", .dst0x, .tmp0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .yword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .yword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_pd, .cmp, .tmp0y, .src0y, .src0y, .vp(.unord) },
                        .{ ._, .v_pd, .max, .dst0y, .src1y, .src0y, ._ },
                        .{ ._, .v_pd, .blendv, .dst0y, .dst0y, .src1y, .tmp0y },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_pd, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                        .{ ._, .v_pd, .mova, .tmp2y, .memia(.src1y, .tmp0, .add_size), ._, ._ },
                        .{ ._, .v_pd, .cmp, .tmp3y, .tmp1y, .tmp1y, .vp(.unord) },
                        .{ ._, .v_pd, .max, .tmp1y, .tmp2y, .tmp1y, ._ },
                        .{ ._, .v_pd, .blendv, .tmp1y, .tmp1y, .tmp2y, .tmp3y },
                        .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_f64, .kind = .{ .reg = .xmm0 } },
                        .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._pd, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._pd, .mova, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, ._pd, .max, .tmp3x, .tmp1x, ._, ._ },
                        .{ ._, ._pd, .cmp, .tmp1x, .tmp1x, .sp(.unord), ._ },
                        .{ ._, ._pd, .blendv, .tmp3x, .tmp2x, .tmp1x, ._ },
                        .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._pd, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._pd, .mova, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, ._pd, .max, .tmp3x, .tmp1x, ._, ._ },
                        .{ ._, ._pd, .cmp, .tmp1x, .tmp1x, .sp(.ord), ._ },
                        .{ ._, ._pd, .@"and", .tmp3x, .tmp1x, ._, ._ },
                        .{ ._, ._pd, .andn, .tmp1x, .tmp2x, ._, ._ },
                        .{ ._, ._pd, .@"or", .tmp1x, .tmp3x, ._, ._ },
                        .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmax" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._ps, .xor, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._ps, .movl, .tmp2x, .memia(.src1q, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, .cmov, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .mem, .to_x87, .none } },
                        .{ .src = .{ .to_x87, .to_x87, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src1, .rc = .x87 } }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .f_, .ucomi, .tmp0t, .tmp0t, ._, ._ },
                        .{ ._, .f_u, .cmov, .tmp0t, .src1t, ._, ._ },
                        .{ ._, .f_, .xch, .src1t, ._, ._, ._ },
                        .{ ._, .f_, .ucomi, .tmp0t, .src1t, ._, ._ },
                        .{ ._, .f_, .xch, .src1t, ._, ._, ._ },
                        .{ ._, .f_nb, .cmov, .tmp0t, .src1t, ._, ._ },
                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sahf, .x87, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .mem, .to_x87, .none } },
                        .{ .src = .{ .to_x87, .to_x87, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .u16, .kind = .{ .reg = .ax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src1, .rc = .x87 } }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .f_, .ucom, .tmp0t, ._, ._, ._ },
                        .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .sahf, ._, ._, ._, ._ },
                        .{ ._, ._p, .j, .@"0f", ._, ._, ._ },
                        .{ ._, .f_, .xch, .src1t, ._, ._, ._ },
                        .{ ._, .f_, .ucom, .src1t, ._, ._, ._ },
                        .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ },
                        .{ ._, .f_, .xch, .src1t, ._, ._, ._ },
                        .{ ._, ._, .sahf, ._, ._, ._, ._ },
                        .{ ._, ._b, .j, .@"1f", ._, ._, ._ },
                        .{ .@"0:", .f_p, .st, .tmp0t, ._, ._, ._ },
                        .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
                        .{ .@"1:", .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .mem, .to_x87, .none } },
                        .{ .src = .{ .to_x87, .to_x87, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .u16, .kind = .{ .reg = .ax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src1, .rc = .x87 } }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .f_, .xam, ._, ._, ._, ._ },
                        .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .@"test", .tmp1h, .si(0b1_000_100), ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, .f_, .xch, .src1t, ._, ._, ._ },
                        .{ ._, .f_, .ucom, .src1t, ._, ._, ._ },
                        .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ },
                        .{ ._, .f_, .xch, .src1t, ._, ._, ._ },
                        .{ ._, ._, .@"test", .tmp1h, .si(0b0_000_001), ._, ._ },
                        .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                        .{ .@"0:", .f_p, .st, .tmp0t, ._, ._, ._ },
                        .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
                        .{ .@"1:", .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, .cmov, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memia(.src1t, .tmp0, .add_size), ._, ._, ._ },
                        .{ ._, .f_, .ld, .memia(.src0t, .tmp0, .add_size), ._, ._, ._ },
                        .{ ._, .f_, .ucomi, .tmp1t, .tmp1t, ._, ._ },
                        .{ ._, .f_u, .cmov, .tmp1t, .tmp2t, ._, ._ },
                        .{ ._, .f_, .xch, .tmp2t, ._, ._, ._ },
                        .{ ._, .f_, .ucomi, .tmp1t, .tmp2t, ._, ._ },
                        .{ ._, .f_, .xch, .tmp2t, ._, ._, ._ },
                        .{ ._, .f_nb, .cmov, .tmp1t, .tmp2t, ._, ._ },
                        .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_size), ._, ._, ._ },
                        .{ ._, .f_p, .st, .tmp2t, ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sahf, .x87, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .u16, .kind = .{ .reg = .ax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memia(.src1t, .tmp0, .add_size), ._, ._, ._ },
                        .{ ._, .f_, .ld, .memia(.src0t, .tmp0, .add_size), ._, ._, ._ },
                        .{ ._, .f_, .ucom, .tmp1t, ._, ._, ._ },
                        .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ },
                        .{ ._, ._, .sahf, ._, ._, ._, ._ },
                        .{ ._, ._p, .j, .@"1f", ._, ._, ._ },
                        .{ ._, .f_, .xch, .tmp2t, ._, ._, ._ },
                        .{ ._, .f_, .ucom, .tmp2t, ._, ._, ._ },
                        .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ },
                        .{ ._, .f_, .xch, .tmp2t, ._, ._, ._ },
                        .{ ._, ._, .sahf, ._, ._, ._, ._ },
                        .{ ._, ._b, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", .f_p, .st, .tmp1t, ._, ._, ._ },
                        .{ ._, .f_, .ld, .tmp2t, ._, ._, ._ },
                        .{ .@"2:", .f_p, .st, .memia(.dst0t, .tmp0, .add_size), ._, ._, ._ },
                        .{ ._, .f_p, .st, .tmp2t, ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .u16, .kind = .{ .reg = .ax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memia(.src1t, .tmp0, .add_size), ._, ._, ._ },
                        .{ ._, .f_, .ld, .memia(.src0t, .tmp0, .add_size), ._, ._, ._ },
                        .{ ._, .f_, .xam, ._, ._, ._, ._ },
                        .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ },
                        .{ ._, ._, .@"test", .tmp3h, .si(0b1_000_100), ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, .f_, .xch, .tmp2t, ._, ._, ._ },
                        .{ ._, .f_, .ucom, .tmp2t, ._, ._, ._ },
                        .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ },
                        .{ ._, .f_, .xch, .tmp2t, ._, ._, ._ },
                        .{ ._, ._, .@"test", .tmp3h, .si(0b0_000_001), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", .f_p, .st, .tmp1t, ._, ._, ._ },
                        .{ ._, .f_, .ld, .tmp2t, ._, ._, ._ },
                        .{ .@"2:", .f_p, .st, .memia(.dst0t, .tmp0, .add_size), ._, ._, ._ },
                        .{ ._, .f_p, .st, .tmp2t, ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "fmaxq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmaxq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmaxq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp2x, .memi(.src1x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmaxq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .memi(.src1x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmaxq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._ps, .mova, .tmp2x, .memi(.src1x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmaxq" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memi(.src1, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp4x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmaxq" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memi(.src1, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp4x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmaxq" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memi(.src1, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp4x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f} {f}", .{
                        @tagName(air_tag),
                        cg.typeOf(bin_op.lhs).fmt(pt),
                        ops[0].tracking(cg),
                        ops[1].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
            },
            .min => |air_tag| {
                const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                var res: [1]Temp = undefined;
                cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ },
                        .{ ._, ._ge, .cmov, .dst0d, .src1d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ },
                        .{ ._, ._nge, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0b, .src1b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ },
                        .{ ._, ._ae, .cmov, .dst0d, .src1d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ },
                        .{ ._, ._nae, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0b, .src1b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ },
                        .{ ._, ._ge, .cmov, .dst0w, .src1w, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ },
                        .{ ._, ._nge, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0w, .src1w, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ },
                        .{ ._, ._ae, .cmov, .dst0w, .src1w, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ },
                        .{ ._, ._nae, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0w, .src1w, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ },
                        .{ ._, ._ge, .cmov, .dst0d, .src1d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ },
                        .{ ._, ._nge, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .src1d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ },
                        .{ ._, ._ae, .cmov, .dst0d, .src1d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ },
                        .{ ._, ._nae, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .src1d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ },
                        .{ ._, ._ge, .cmov, .dst0q, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ },
                        .{ ._, ._nge, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0q, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ },
                        .{ ._, ._ae, .cmov, .dst0q, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ },
                        .{ ._, ._nae, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0q, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{ .any_signed_int, .any_signed_int, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rsi } },
                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                        .{ ._, ._ge, .cmov, .tmp0p, .tmp1p, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .any_signed_int, .any_signed_int, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rsi } },
                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._nge, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.src1), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{ .any_unsigned_int, .any_unsigned_int, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rsi } },
                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memsia(.src1q, .@"8", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                        .{ ._, ._ae, .cmov, .tmp0p, .tmp1p, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .any_unsigned_int, .any_unsigned_int, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .reg = .rsi } },
                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memsia(.src1q, .@"8", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._nae, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.src1), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_b, .mins, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_b, .mins, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._dqa, .mov, .dst0x, .src1x, ._, ._ },
                        .{ ._, .p_b, .cmpgt, .dst0x, .src0x, ._, ._ },
                        .{ ._, .p_, .@"and", .src0x, .dst0x, ._, ._ },
                        .{ ._, .p_, .andn, .dst0x, .src1x, ._, ._ },
                        .{ ._, .p_, .@"or", .dst0x, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .yword, .is = .byte } },
                        .{ .scalar_signed_int = .{ .of = .yword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_b, .mins, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                        .{ ._, .vp_b, .mins, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .vp_b, .mins, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .p_b, .mins, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .p_b, .cmpgt, .tmp1x, .tmp2x, ._, ._ },
                        .{ ._, .p_, .@"and", .tmp2x, .tmp1x, ._, ._ },
                        .{ ._, .p_, .andn, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .p_, .@"or", .tmp1x, .tmp2x, ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .movsx, .tmp2d, .memia(.src1b, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp2b, ._, ._ },
                        .{ ._, ._ge, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .movsx, .tmp2d, .memia(.src1b, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp2b, ._, ._ },
                        .{ ._, ._ge, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .memia(.src1b, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._nge, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1b, .memia(.src1b, .tmp0, .add_size), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .memia(.src1b, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._nge, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1b, .memia(.src1b, .tmp0, .add_size), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, .mmx, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } },
                        .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_mmx, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_mmx, .to_mmx, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_b, .minu, .dst0q, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_b, .minu, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_b, .minu, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .yword, .is = .byte } },
                        .{ .scalar_unsigned_int = .{ .of = .yword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_b, .minu, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                        .{ ._, .vp_b, .minu, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .vp_b, .minu, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .p_b, .minu, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .movzx, .tmp2d, .memia(.src1b, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp2b, ._, ._ },
                        .{ ._, ._ae, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .movzx, .tmp2d, .memia(.src1b, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp2b, ._, ._ },
                        .{ ._, ._ae, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .memia(.src1b, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1b, .memia(.src1b, .tmp0, .add_size), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .memia(.src1b, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1b, .memia(.src1b, .tmp0, .add_size), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, .mmx, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .qword, .is = .word } },
                        .{ .scalar_signed_int = .{ .of = .qword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_mmx, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_mmx, .to_mmx, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_w, .mins, .dst0q, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .word } },
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .mins, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .word } },
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_w, .mins, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .yword, .is = .word } },
                        .{ .scalar_signed_int = .{ .of = .yword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .mins, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } },
                        .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                        .{ ._, .vp_w, .mins, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } },
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .vp_w, .mins, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } },
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .p_w, .mins, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1w, .memia(.src1w, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._ge, .cmov, .tmp1w, .memia(.src1w, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1w, .memia(.src1w, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._nge, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1w, .memia(.src1w, .tmp0, .add_size), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .minu, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_w, .minu, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._dqa, .mov, .dst0x, .src0x, ._, ._ },
                        .{ ._, .p_w, .subus, .src0x, .src1x, ._, ._ },
                        .{ ._, .p_w, .sub, .dst0x, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .yword, .is = .word } },
                        .{ .scalar_unsigned_int = .{ .of = .yword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .minu, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .word } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                        .{ ._, .vp_w, .minu, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .vp_w, .minu, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .p_w, .minu, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ },
                        .{ ._, .p_w, .subus, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .p_w, .sub, .tmp2x, .tmp1x, ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp2x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1w, .memia(.src1w, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._ae, .cmov, .tmp1w, .memia(.src1w, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1w, .memia(.src1w, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1w, .memia(.src1w, .tmp0, .add_size), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .mins, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_d, .mins, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_or_exclusive_int = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_signed_or_exclusive_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._dqa, .mov, .dst0x, .src1x, ._, ._ },
                        .{ ._, .p_d, .cmpgt, .dst0x, .src0x, ._, ._ },
                        .{ ._, .p_, .@"and", .src0x, .dst0x, ._, ._ },
                        .{ ._, .p_, .andn, .dst0x, .src1x, ._, ._ },
                        .{ ._, .p_, .@"or", .dst0x, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_int = .{ .of = .yword, .is = .dword } },
                        .{ .scalar_signed_int = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .mins, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                        .{ ._, .vp_d, .mins, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .vp_d, .mins, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .p_d, .mins, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_or_exclusive_int = .{ .of = .xword, .is = .dword } },
                        .{ .multiple_scalar_signed_or_exclusive_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .p_d, .cmpgt, .tmp1x, .tmp2x, ._, ._ },
                        .{ ._, .p_, .@"and", .tmp2x, .tmp1x, ._, ._ },
                        .{ ._, .p_, .andn, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .p_, .@"or", .tmp1x, .tmp2x, ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._ge, .cmov, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._nge, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0d, .tmp0, .add_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .minu, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_d, .minu, .dst0x, .src1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 32 } },
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 32 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u32, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
                        .{ ._, .p_, .xor, .dst0x, .src1x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .src0x, ._, ._ },
                        .{ ._, .p_d, .cmpgt, .dst0x, .tmp2x, ._, ._ },
                        .{ ._, .p_, .@"and", .src0x, .dst0x, ._, ._ },
                        .{ ._, .p_, .andn, .dst0x, .src1x, ._, ._ },
                        .{ ._, .p_, .@"or", .dst0x, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_unsigned_int = .{ .of = .yword, .is = .dword } },
                        .{ .scalar_unsigned_int = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .minu, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                        .{ ._, .vp_d, .minu, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .vp_d, .minu, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .p_d, .minu, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 32 } },
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 32 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u32, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp5x, .tmp3x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp6x, .tmp4x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp5x, .tmp2x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp6x, .tmp2x, ._, ._ },
                        .{ ._, .p_d, .cmpgt, .tmp5x, .tmp6x, ._, ._ },
                        .{ ._, .p_, .@"and", .tmp4x, .tmp5x, ._, ._ },
                        .{ ._, .p_, .andn, .tmp5x, .tmp3x, ._, ._ },
                        .{ ._, .p_, .@"or", .tmp4x, .tmp5x, ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp4x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._ae, .cmov, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0d, .tmp0, .add_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_or_exclusive_int = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_signed_or_exclusive_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_q, .cmpgt, .dst0x, .src0x, .src1x, ._ },
                        .{ ._, .vp_b, .blendv, .dst0x, .src0x, .src1x, .dst0x },
                    } },
                }, .{
                    .required_features = .{ .sse4_2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_or_exclusive_int = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_signed_or_exclusive_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._dqa, .mov, .tmp0x, .src0x, ._, ._ },
                        .{ ._, .p_q, .cmpgt, .tmp0x, .src1x, ._, ._ },
                        .{ ._, .p_b, .blendv, .dst0x, .src1x, .tmp0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_signed_or_exclusive_int = .{ .of = .yword, .is = .qword } },
                        .{ .scalar_signed_or_exclusive_int = .{ .of = .yword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_q, .cmpgt, .dst0y, .src0y, .src1y, ._ },
                        .{ ._, .vp_b, .blendv, .dst0y, .src0y, .src1y, .dst0y },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_or_exclusive_int = .{ .of = .yword, .is = .qword } },
                        .{ .multiple_scalar_signed_or_exclusive_int = .{ .of = .yword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp2y, .memia(.src1y, .tmp0, .add_size), ._, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp3y, .tmp1y, .tmp2y, ._ },
                        .{ ._, .vp_b, .blendv, .tmp1y, .tmp1y, .tmp2y, .tmp3y },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_or_exclusive_int = .{ .of = .xword, .is = .qword } },
                        .{ .multiple_scalar_signed_or_exclusive_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp3x, .tmp1x, .tmp2x, ._ },
                        .{ ._, .vp_b, .blendv, .tmp1x, .tmp1x, .tmp2x, .tmp3x },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_or_exclusive_int = .{ .of = .xword, .is = .qword } },
                        .{ .multiple_scalar_signed_or_exclusive_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp3x, .tmp1x, ._, ._ },
                        .{ ._, .p_q, .cmpgt, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, .p_b, .blendv, .tmp1x, .tmp2x, .tmp3x, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._ge, .cmov, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._nge, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, .vp_, .xor, .dst0x, .tmp2x, .src0x, ._ },
                        .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .src1x, ._ },
                        .{ ._, .vp_q, .cmpgt, .dst0x, .dst0x, .tmp2x, ._ },
                        .{ ._, .vp_b, .blendv, .dst0x, .src0x, .src1x, .dst0x },
                    } },
                }, .{
                    .required_features = .{ .sse4_2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_2_u64, .kind = .{ .reg = .xmm0 } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .src0x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp3x, .src1x, ._, ._ },
                        .{ ._, .p_q, .cmpgt, .tmp2x, .tmp3x, ._, ._ },
                        .{ ._, .p_b, .blendv, .dst0x, .src1x, .tmp2x, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_exact_unsigned_int = .{ .of = .yword, .is = 64 } },
                        .{ .scalar_exact_unsigned_int = .{ .of = .yword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ },
                        .{ ._, .vp_, .xor, .dst0y, .tmp2y, .src0y, ._ },
                        .{ ._, .vp_, .xor, .tmp2y, .tmp2y, .src1y, ._ },
                        .{ ._, .vp_q, .cmpgt, .dst0y, .dst0y, .tmp2y, ._ },
                        .{ ._, .vp_b, .blendv, .dst0y, .src0y, .src1y, .dst0y },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .yword, .is = 64 } },
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .yword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp4y, .memia(.src1y, .tmp0, .add_size), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp5y, .tmp3y, .tmp2y, ._ },
                        .{ ._, .vp_, .xor, .tmp6y, .tmp4y, .tmp2y, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp5y, .tmp5y, .tmp6y, ._ },
                        .{ ._, .vp_b, .blendv, .tmp3y, .tmp3y, .tmp4y, .tmp5y },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp3y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp5x, .tmp3x, .tmp2x, ._ },
                        .{ ._, .vp_, .xor, .tmp6x, .tmp4x, .tmp2x, ._ },
                        .{ ._, .vp_q, .cmpgt, .tmp5x, .tmp5x, .tmp6x, ._ },
                        .{ ._, .vp_b, .blendv, .tmp3x, .tmp3x, .tmp4x, .tmp5x },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .reg = .xmm0 } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp5x, .tmp2x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp6x, .tmp2x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .p_, .xor, .tmp5x, .tmp3x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp6x, .tmp4x, ._, ._ },
                        .{ ._, .p_q, .cmpgt, .tmp5x, .tmp6x, ._, ._ },
                        .{ ._, .p_b, .blendv, .tmp3x, .tmp4x, .tmp5x, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._ae, .cmov, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{ .any_scalar_signed_int, .any_scalar_signed_int, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .reg = .rsi } },
                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .sia(-1, .none, .add_src0_elem_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sbb, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sbb, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memiad(.src0, .tmp0, .add_unaligned_size_sub_elem_size, 8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memiad(.src1, .tmp0, .add_unaligned_size_sub_elem_size, 8), ._, ._ },
                        .{ ._, ._ge, .cmov, .tmp1p, .tmp2p, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memiad(.dst0, .tmp0, .add_unaligned_size_sub_elem_size, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.none, .add_src0_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .any_scalar_signed_int, .any_scalar_signed_int, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .reg = .rsi } },
                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .sia(-1, .none, .add_src0_elem_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sbb, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sbb, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memiad(.src0, .tmp0, .add_unaligned_size_sub_elem_size, 8), ._, ._ },
                        .{ ._, ._nge, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memiad(.src1, .tmp0, .add_unaligned_size_sub_elem_size, 8), ._, ._ },
                        .{ .@"1:", ._, .lea, .tmp2p, .memiad(.dst0, .tmp0, .add_unaligned_size_sub_elem_size, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.none, .add_src0_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{ .any_scalar_unsigned_int, .any_scalar_unsigned_int, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .reg = .rsi } },
                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .sa(.none, .add_src0_elem_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sbb, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memia(.src1, .tmp0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ ._, ._ae, .cmov, .tmp1p, .tmp2p, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memia(.dst0, .tmp0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.none, .add_src0_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._, .@"test", .tmp0p, .tmp0p, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .any_scalar_unsigned_int, .any_scalar_unsigned_int, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .reg = .rsi } },
                        .{ .type = .u64, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rcx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .sa(.none, .add_src0_elem_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .sbb, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memia(.src1, .tmp0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ .@"1:", ._, .lea, .tmp2p, .memia(.dst0, .tmp0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.none, .add_src0_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._, .@"test", .tmp0p, .tmp0p, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .{ .type = .f16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
                        .{ ._, .v_ss, .cmp, .tmp1x, .dst0x, .dst0d, .vp(.unord) },
                        .{ ._, .v_ss, .min, .dst0x, .tmp0x, .dst0d, ._ },
                        .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp0x, .tmp1x },
                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__fminh" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .word } },
                        .{ .scalar_float = .{ .of = .qword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_4_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
                        .{ ._, .v_ps, .cmp, .tmp1x, .dst0x, .dst0x, .vp(.unord) },
                        .{ ._, .v_ps, .min, .dst0x, .tmp0x, .dst0x, ._ },
                        .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp0x, .tmp1x },
                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .word } },
                        .{ .scalar_float = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .none } },
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ },
                        .{ ._, .v_ps, .cmp, .tmp1y, .dst0y, .dst0y, .vp(.unord) },
                        .{ ._, .v_ps, .min, .dst0y, .tmp0y, .dst0y, ._ },
                        .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp0y, .tmp1y },
                        .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .v_ps, .cmp, .tmp3y, .tmp1y, .tmp1y, .vp(.unord) },
                        .{ ._, .v_ps, .min, .tmp1y, .tmp2y, .tmp1y, ._ },
                        .{ ._, .v_ps, .blendv, .tmp1y, .tmp1y, .tmp2y, .tmp3y },
                        .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_size), .tmp1y, .rm(.{}), ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fminh" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ },
                        .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memia(.src0w, .tmp0, .add_size), .ui(0) },
                        .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memia(.src1w, .tmp0, .add_size), .ui(0) },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_size), .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fminh" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_size), .ui(0), ._ },
                        .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_size), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_size), .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fminh" } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_size), .ui(0), ._ },
                        .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_size), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .tmp4d, .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_size), .tmp4w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fminh" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ss, .cmp, .tmp0x, .src0x, .src0d, .vp(.unord) },
                        .{ ._, .v_ss, .min, .dst0x, .src1x, .src0d, ._ },
                        .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .src1x, .tmp0x },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._ps, .mova, .dst0x, .src1x, ._, ._ },
                        .{ ._, ._ss, .min, .dst0x, .src0d, ._, ._ },
                        .{ ._, ._ss, .cmp, .src0x, .src0d, .sp(.unord), ._ },
                        .{ ._, ._ps, .blendv, .dst0x, .src1x, .src0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._ps, .mova, .tmp0x, .src1x, ._, ._ },
                        .{ ._, ._ss, .min, .tmp0x, .src0d, ._, ._ },
                        .{ ._, ._ss, .cmp, .dst0x, .src0d, .sp(.ord), ._ },
                        .{ ._, ._ps, .@"and", .tmp0x, .dst0x, ._, ._ },
                        .{ ._, ._ps, .andn, .dst0x, .src1x, ._, ._ },
                        .{ ._, ._ps, .@"or", .dst0x, .tmp0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cmp, .tmp0x, .src0x, .src0x, .vp(.unord) },
                        .{ ._, .v_ps, .min, .dst0x, .src1x, .src0x, ._ },
                        .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .src1x, .tmp0x },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .xmm0 }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .xmm0 }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._ps, .mova, .dst0x, .src1x, ._, ._ },
                        .{ ._, ._ps, .min, .dst0x, .src0x, ._, ._ },
                        .{ ._, ._ps, .cmp, .src0x, .src0x, .sp(.unord), ._ },
                        .{ ._, ._ps, .blendv, .dst0x, .src1x, .src0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._ps, .mova, .tmp0x, .src1x, ._, ._ },
                        .{ ._, ._ps, .min, .tmp0x, .src0x, ._, ._ },
                        .{ ._, ._ps, .cmp, .dst0x, .src0x, .sp(.ord), ._ },
                        .{ ._, ._ps, .@"and", .tmp0x, .dst0x, ._, ._ },
                        .{ ._, ._ps, .andn, .dst0x, .src1x, ._, ._ },
                        .{ ._, ._ps, .@"or", .dst0x, .tmp0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .yword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cmp, .tmp0y, .src0y, .src0y, .vp(.unord) },
                        .{ ._, .v_ps, .min, .dst0y, .src1y, .src0y, ._ },
                        .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .src1y, .tmp0y },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_ps, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                        .{ ._, .v_ps, .mova, .tmp2y, .memia(.src1y, .tmp0, .add_size), ._, ._ },
                        .{ ._, .v_ps, .cmp, .tmp3y, .tmp1y, .tmp1y, .vp(.unord) },
                        .{ ._, .v_ps, .min, .tmp1y, .tmp2y, .tmp1y, ._ },
                        .{ ._, .v_ps, .blendv, .tmp1y, .tmp1y, .tmp2y, .tmp3y },
                        .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_f32, .kind = .{ .reg = .xmm0 } },
                        .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._ps, .mova, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, ._ps, .min, .tmp3x, .tmp1x, ._, ._ },
                        .{ ._, ._ps, .cmp, .tmp1x, .tmp1x, .sp(.unord), ._ },
                        .{ ._, ._ps, .blendv, .tmp3x, .tmp2x, .tmp1x, ._ },
                        .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._ps, .mova, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, ._ps, .min, .tmp3x, .tmp1x, ._, ._ },
                        .{ ._, ._ps, .cmp, .tmp1x, .tmp1x, .sp(.ord), ._ },
                        .{ ._, ._ps, .@"and", .tmp3x, .tmp1x, ._, ._ },
                        .{ ._, ._ps, .andn, .tmp1x, .tmp2x, ._, ._ },
                        .{ ._, ._ps, .@"or", .tmp1x, .tmp3x, ._, ._ },
                        .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_sd, .cmp, .tmp0x, .src0x, .src0q, .vp(.unord) },
                        .{ ._, .v_sd, .min, .dst0x, .src1x, .src0q, ._ },
                        .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .src1x, .tmp0x },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._pd, .mova, .dst0x, .src1x, ._, ._ },
                        .{ ._, ._sd, .min, .dst0x, .src0q, ._, ._ },
                        .{ ._, ._sd, .cmp, .src0x, .src0q, .sp(.unord), ._ },
                        .{ ._, ._pd, .blendv, .dst0x, .src1x, .src0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._pd, .mova, .tmp0x, .src1x, ._, ._ },
                        .{ ._, ._sd, .min, .tmp0x, .src0q, ._, ._ },
                        .{ ._, ._sd, .cmp, .dst0x, .src0q, .sp(.ord), ._ },
                        .{ ._, ._pd, .@"and", .tmp0x, .dst0x, ._, ._ },
                        .{ ._, ._pd, .andn, .dst0x, .src1x, ._, ._ },
                        .{ ._, ._pd, .@"or", .dst0x, .tmp0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "fmin" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_pd, .cmp, .tmp0x, .src0x, .src0x, .vp(.unord) },
                        .{ ._, .v_pd, .min, .dst0x, .src1x, .src0x, ._ },
                        .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .src1x, .tmp0x },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .xmm0 }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .xmm0 }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._pd, .mova, .dst0x, .src1x, ._, ._ },
                        .{ ._, ._pd, .min, .dst0x, .src0x, ._, ._ },
                        .{ ._, ._pd, .cmp, .src0x, .src0x, .sp(.unord), ._ },
                        .{ ._, ._pd, .blendv, .dst0x, .src1x, .src0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._pd, .mova, .tmp0x, .src1x, ._, ._ },
                        .{ ._, ._pd, .min, .tmp0x, .src0x, ._, ._ },
                        .{ ._, ._pd, .cmp, .dst0x, .src0x, .sp(.ord), ._ },
                        .{ ._, ._pd, .@"and", .tmp0x, .dst0x, ._, ._ },
                        .{ ._, ._pd, .andn, .dst0x, .src1x, ._, ._ },
                        .{ ._, ._pd, .@"or", .dst0x, .tmp0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .yword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .yword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_pd, .cmp, .tmp0y, .src0y, .src0y, .vp(.unord) },
                        .{ ._, .v_pd, .min, .dst0y, .src1y, .src0y, ._ },
                        .{ ._, .v_pd, .blendv, .dst0y, .dst0y, .src1y, .tmp0y },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_pd, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                        .{ ._, .v_pd, .mova, .tmp2y, .memia(.src1y, .tmp0, .add_size), ._, ._ },
                        .{ ._, .v_pd, .cmp, .tmp3y, .tmp1y, .tmp1y, .vp(.unord) },
                        .{ ._, .v_pd, .min, .tmp1y, .tmp2y, .tmp1y, ._ },
                        .{ ._, .v_pd, .blendv, .tmp1y, .tmp1y, .tmp2y, .tmp3y },
                        .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_f64, .kind = .{ .reg = .xmm0 } },
                        .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._pd, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._pd, .mova, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, ._pd, .min, .tmp3x, .tmp1x, ._, ._ },
                        .{ ._, ._pd, .cmp, .tmp1x, .tmp1x, .sp(.unord), ._ },
                        .{ ._, ._pd, .blendv, .tmp3x, .tmp2x, .tmp1x, ._ },
                        .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._pd, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._pd, .mova, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, ._pd, .min, .tmp3x, .tmp1x, ._, ._ },
                        .{ ._, ._pd, .cmp, .tmp1x, .tmp1x, .sp(.ord), ._ },
                        .{ ._, ._pd, .@"and", .tmp3x, .tmp1x, ._, ._ },
                        .{ ._, ._pd, .andn, .tmp1x, .tmp2x, ._, ._ },
                        .{ ._, ._pd, .@"or", .tmp1x, .tmp3x, ._, ._ },
                        .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmin" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._ps, .xor, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._ps, .movl, .tmp2x, .memia(.src1q, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, .cmov, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .mem, .to_x87, .none } },
                        .{ .src = .{ .to_x87, .to_x87, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src1, .rc = .x87 } }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .f_, .ucomi, .tmp0t, .tmp0t, ._, ._ },
                        .{ ._, .f_u, .cmov, .tmp0t, .src1t, ._, ._ },
                        .{ ._, .f_, .ucomi, .tmp0t, .src1t, ._, ._ },
                        .{ ._, .f_nb, .cmov, .tmp0t, .src1t, ._, ._ },
                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sahf, .x87, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .mem, .to_x87, .none } },
                        .{ .src = .{ .to_x87, .to_x87, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .u16, .kind = .{ .reg = .ax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src1, .rc = .x87 } }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .f_, .ucom, .tmp0t, ._, ._, ._ },
                        .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .sahf, ._, ._, ._, ._ },
                        .{ ._, ._p, .j, .@"0f", ._, ._, ._ },
                        .{ ._, .f_, .ucom, .src1t, ._, ._, ._ },
                        .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .sahf, ._, ._, ._, ._ },
                        .{ ._, ._b, .j, .@"1f", ._, ._, ._ },
                        .{ .@"0:", .f_p, .st, .tmp0t, ._, ._, ._ },
                        .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
                        .{ .@"1:", .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .mem, .to_x87, .none } },
                        .{ .src = .{ .to_x87, .to_x87, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .u16, .kind = .{ .reg = .ax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src1, .rc = .x87 } }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .f_, .xam, ._, ._, ._, ._ },
                        .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .@"test", .tmp1h, .si(0b1_000_100), ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, .f_, .ucom, .src1t, ._, ._, ._ },
                        .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .@"test", .tmp1h, .si(0b0_000_001), ._, ._ },
                        .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                        .{ .@"0:", .f_p, .st, .tmp0t, ._, ._, ._ },
                        .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
                        .{ .@"1:", .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, .cmov, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memia(.src1t, .tmp0, .add_size), ._, ._, ._ },
                        .{ ._, .f_, .ld, .memia(.src0t, .tmp0, .add_size), ._, ._, ._ },
                        .{ ._, .f_, .ucomi, .tmp1t, .tmp1t, ._, ._ },
                        .{ ._, .f_u, .cmov, .tmp1t, .tmp2t, ._, ._ },
                        .{ ._, .f_, .ucomi, .tmp1t, .tmp2t, ._, ._ },
                        .{ ._, .f_nb, .cmov, .tmp1t, .tmp2t, ._, ._ },
                        .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_size), ._, ._, ._ },
                        .{ ._, .f_p, .st, .tmp2t, ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sahf, .x87, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .u16, .kind = .{ .reg = .ax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memia(.src1t, .tmp0, .add_size), ._, ._, ._ },
                        .{ ._, .f_, .ld, .memia(.src0t, .tmp0, .add_size), ._, ._, ._ },
                        .{ ._, .f_, .ucom, .tmp1t, ._, ._, ._ },
                        .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ },
                        .{ ._, ._, .sahf, ._, ._, ._, ._ },
                        .{ ._, ._p, .j, .@"1f", ._, ._, ._ },
                        .{ ._, .f_, .ucom, .tmp2t, ._, ._, ._ },
                        .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ },
                        .{ ._, ._, .sahf, ._, ._, ._, ._ },
                        .{ ._, ._b, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", .f_p, .st, .tmp1t, ._, ._, ._ },
                        .{ ._, .f_, .ld, .tmp2t, ._, ._, ._ },
                        .{ .@"2:", .f_p, .st, .memia(.dst0t, .tmp0, .add_size), ._, ._, ._ },
                        .{ ._, .f_p, .st, .tmp2t, ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .u16, .kind = .{ .reg = .ax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memia(.src1t, .tmp0, .add_size), ._, ._, ._ },
                        .{ ._, .f_, .ld, .memia(.src0t, .tmp0, .add_size), ._, ._, ._ },
                        .{ ._, .f_, .xam, ._, ._, ._, ._ },
                        .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ },
                        .{ ._, ._, .@"test", .tmp3h, .si(0b1_000_100), ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, .f_, .ucom, .tmp2t, ._, ._, ._ },
                        .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ },
                        .{ ._, ._, .@"test", .tmp3h, .si(0b0_000_001), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", .f_p, .st, .tmp1t, ._, ._, ._ },
                        .{ ._, .f_, .ld, .tmp2t, ._, ._, ._ },
                        .{ .@"2:", .f_p, .st, .memia(.dst0t, .tmp0, .add_size), ._, ._, ._ },
                        .{ ._, .f_p, .st, .tmp2t, ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .none,
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "fminq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fminq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fminq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fminq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fminq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fminq" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memi(.src1, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp4x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fminq" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memi(.src1, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp4x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fminq" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memi(.src1, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp4x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f} {f}", .{
                        @tagName(air_tag),
                        cg.typeOf(bin_op.lhs).fmt(pt),
                        ops[0].tracking(cg),
                        ops[1].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
            },
            .add_with_overflow => |air_tag| {
                const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
                const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data;
                var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                var res: [2]Temp = undefined;
                cg.select(&res, &.{ ty_pl.ty.toType(), .u1 }, &ops, comptime &.{ .{
                    .src_constraints = .{ .{ .exact_signed_int = 8 }, .{ .exact_signed_int = 8 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                        .{ .src = .{ .imm8, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0b, .src1b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_unsigned_int = 8 }, .{ .exact_unsigned_int = 8 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                        .{ .src = .{ .imm8, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0b, .src1b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                        .{ .src = .{ .imm8, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i8, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .po } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0b, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._l, .sa, .dst0b, .uia(8, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .dst0b, .uia(8, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .@"test", .tmp0b, .sia(-1 << 7, .src0, .sub_smin), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                        .{ .src = .{ .imm8, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .b } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0b, .src1b, ._, ._ },
                        .{ ._, ._, .@"and", .dst0b, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .cmp, .dst0b, .src1b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_signed_int = 16 }, .{ .exact_signed_int = 16 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0w, .src1w, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_unsigned_int = 16 }, .{ .exact_unsigned_int = 16 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0w, .src1w, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                    },
                    .extra_temps = .{
                        .{ .type = .i32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._l, .ro, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sa, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .ro, .tmp0d, .ui(1), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                    },
                    .extra_temps = .{
                        .{ .type = .i32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._l, .ro, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sa, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .ro, .tmp0d, .ui(1), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .b } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._, .@"and", .dst0w, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .cmp, .dst0w, .src1w, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .b } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .@"and", .dst0w, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .cmp, .dst0w, .src1w, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .b } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .@"and", .dst0d, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .cmp, .dst0w, .src1w, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_signed_int = 32 }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm32, .none } },
                        .{ .src = .{ .imm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0d, .src1d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .{ .exact_unsigned_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm32, .none } },
                        .{ .src = .{ .imm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0d, .src1d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi2, null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 31 }, .{ .exact_signed_int = 31 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm32, .none } },
                        .{ .src = .{ .imm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u8, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .ui(1), ._, ._ },
                        .{ ._, ._, .add, .dst0d, .dst0d, ._, ._ },
                        .{ ._, ._rx, .sa, .dst0d, .dst0d, .tmp0d, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm32, .none } },
                        .{ .src = .{ .imm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._l, .ro, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sa, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .ro, .tmp0d, .ui(1), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm32, .none } },
                        .{ .src = .{ .imm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .b } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .@"and", .dst0d, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .cmp, .dst0d, .src1d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 64 }, .{ .exact_signed_int = 64 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .simm32, .none } },
                        .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0q, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .{ .exact_unsigned_int = 64 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .simm32, .none } },
                        .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0q, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 63 }, .{ .exact_signed_int = 63 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .simm32, .none } },
                        .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u8, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0q, .src1q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .ui(1), ._, ._ },
                        .{ ._, ._, .add, .dst0q, .dst0q, ._, ._ },
                        .{ ._, ._rx, .sa, .dst0q, .dst0q, .tmp0q, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .simm32, .none } },
                        .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0q, .src1q, ._, ._ },
                        .{ ._, ._l, .ro, .dst0q, .uia(64, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ },
                        .{ ._, ._r, .sa, .dst0q, .uia(64, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .ro, .tmp0q, .ui(1), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .simm32, .none } },
                        .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .b } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .add, .dst0q, .src1q, ._, ._ },
                        .{ ._, ._, .bzhi, .dst0q, .dst0q, .tmp0q, ._ },
                        .{ ._, ._, .cmp, .dst0q, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .simm32, .none } },
                        .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .{ .cc = .b } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .add, .src0q, .src1q, ._, ._ },
                        .{ ._, ._, .@"and", .dst0q, .src0q, ._, ._ },
                        .{ ._, ._, .cmp, .dst0q, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 64 } },
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .none },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(2, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -16), ._, ._ },
                        .{ ._, ._, .adc, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -16), .tmp1q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -16), ._, ._ },
                        .{ ._, ._, .adc, .tmp1q, .memad(.src1q, .add_size, -16), ._, ._ },
                        .{ ._, ._o, .set, .mema(.dst0b, .add_src0_size), ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp1q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .c } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp1q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .ui(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 128 } },
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 128 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .o } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp1q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp1q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 128 } },
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 128 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .c } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp1q, .memsia(.src1q, .@"8", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_src0_size), .tmp1q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } },
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .o } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(2, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -16), ._, ._ },
                        .{ ._, ._, .adc, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -16), .tmp1q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -16), ._, ._ },
                        .{ ._, ._, .adc, .tmp1q, .memad(.src1q, .add_size, -16), ._, ._ },
                        .{ ._, ._l, .ro, .tmp1q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp1q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._r, .ro, .tmp0q, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .rc = .general_purpose } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(2, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .dst1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -16), ._, ._ },
                        .{ ._, ._, .adc, .dst1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -16), .dst1q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst1q, .memad(.src0q, .add_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .adc, .dst1q, .memad(.src1q, .add_size, -16), ._, ._ },
                        .{ ._, ._, .bzhi, .tmp0q, .dst1q, .tmp0q, ._ },
                        .{ ._, ._r, .sh, .dst1q, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .ui(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .rc = .general_purpose } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(2, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .dst1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -16), ._, ._ },
                        .{ ._, ._, .adc, .dst1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -16), .dst1q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst1q, .memad(.src0q, .add_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .adc, .dst1q, .memad(.src1q, .add_size, -16), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0q, .dst1q, ._, ._ },
                        .{ ._, ._r, .sh, .dst1q, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .ui(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } },
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .o } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp1q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp1q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._l, .ro, .tmp1q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .ro, .tmp0q, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .rc = .general_purpose } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .dst1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .dst1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .dst1q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .adc, .dst1q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .bzhi, .tmp0q, .dst1q, .tmp0q, ._ },
                        .{ ._, ._r, .sh, .dst1q, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .rc = .general_purpose } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .dst1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .dst1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .dst1q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .adc, .dst1q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0q, .dst1q, ._, ._ },
                        .{ ._, ._r, .sh, .dst1q, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f} {f}", .{
                        @tagName(air_tag),
                        ty_pl.ty.toType().fmt(pt),
                        ops[0].tracking(cg),
                        ops[1].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].withOverflow(&res[1], cg);
                try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
            },
            .sub_with_overflow => |air_tag| {
                const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
                const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data;
                var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                var res: [2]Temp = undefined;
                cg.select(&res, &.{ ty_pl.ty.toType(), .u1 }, &ops, comptime &.{ .{
                    .src_constraints = .{ .{ .exact_signed_int = 8 }, .{ .exact_signed_int = 8 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0b, .src1b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_unsigned_int = 8 }, .{ .exact_unsigned_int = 8 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0b, .src1b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i8, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .po } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0b, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._l, .sa, .dst0b, .uia(8, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .dst0b, .uia(8, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .@"test", .tmp0b, .sia(-1 << 7, .src0, .sub_smin), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .immut_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .rc = .general_purpose } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .dst1d, .dst1d, ._, ._ },
                        .{ ._, ._, .sub, .dst0b, .src1b, ._, ._ },
                        .{ ._, ._c, .set, .dst1b, ._, ._, ._ },
                        .{ ._, ._, .@"and", .dst0b, .ua(.src0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .to_mut_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .ref = .src1 } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0b, .src1b, ._, ._ },
                        .{ ._, ._c, .set, .dst1b, ._, ._, ._ },
                        .{ ._, ._, .@"and", .dst0b, .ua(.src0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_signed_int = 16 }, .{ .exact_signed_int = 16 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_unsigned_int = 16 }, .{ .exact_unsigned_int = 16 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._l, .ro, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sa, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .ro, .tmp0d, .ui(1), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._l, .ro, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sa, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .ro, .tmp0d, .ui(1), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .immut_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .rc = .general_purpose } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .dst1d, .dst1d, ._, ._ },
                        .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._c, .set, .dst1b, ._, ._, ._ },
                        .{ ._, ._, .@"and", .dst0w, .ua(.src0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .to_mut_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .ref = .src1 } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._c, .set, .dst1b, ._, ._, ._ },
                        .{ ._, ._, .@"and", .dst0w, .ua(.src0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .immut_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .rc = .general_purpose } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .dst1d, .dst1d, ._, ._ },
                        .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._c, .set, .dst1b, ._, ._, ._ },
                        .{ ._, ._, .@"and", .dst0d, .ua(.src0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .to_mut_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .ref = .src1 } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ },
                        .{ ._, ._c, .set, .dst1b, ._, ._, ._ },
                        .{ ._, ._, .@"and", .dst0d, .ua(.src0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_signed_int = 32 }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm32, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0d, .src1d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .{ .exact_unsigned_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm32, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0d, .src1d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi2, null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 31 }, .{ .exact_signed_int = 31 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm32, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u8, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .ui(1), ._, ._ },
                        .{ ._, ._, .add, .dst0d, .dst0d, ._, ._ },
                        .{ ._, ._rx, .sa, .dst0d, .dst0d, .tmp0d, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm32, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._l, .ro, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sa, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .ro, .tmp0d, .ui(1), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm32, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .immut_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .rc = .general_purpose } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .dst1d, .dst1d, ._, ._ },
                        .{ ._, ._, .sub, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._c, .set, .dst1b, ._, ._, ._ },
                        .{ ._, ._, .@"and", .dst0d, .ua(.src0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .to_mut_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .ref = .src1 } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0d, .src1d, ._, ._ },
                        .{ ._, ._c, .set, .dst1b, ._, ._, ._ },
                        .{ ._, ._, .@"and", .dst0d, .ua(.src0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 64 }, .{ .exact_signed_int = 64 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .simm32, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0q, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .{ .exact_unsigned_int = 64 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .simm32, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0q, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 63 }, .{ .exact_signed_int = 63 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .simm32, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u8, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0q, .src1q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .ui(1), ._, ._ },
                        .{ ._, ._, .add, .dst0q, .dst0q, ._, ._ },
                        .{ ._, ._rx, .sa, .dst0q, .dst0q, .tmp0q, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .simm32, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .sub, .dst0q, .src1q, ._, ._ },
                        .{ ._, ._l, .ro, .dst0q, .uia(64, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ },
                        .{ ._, ._r, .sa, .dst0q, .uia(64, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .ro, .tmp0q, .ui(1), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .simm32, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .immut_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .rc = .general_purpose } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .dst1d, .dst1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .sub, .dst0q, .src1q, ._, ._ },
                        .{ ._, ._c, .set, .dst1b, ._, ._, ._ },
                        .{ ._, ._, .bzhi, .dst0q, .dst0q, .tmp0q, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .to_mut_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .ref = .src1 } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .sub, .dst0q, .src1q, ._, ._ },
                        .{ ._, ._c, .set, .dst1b, ._, ._, ._ },
                        .{ ._, ._, .bzhi, .dst0q, .dst0q, .tmp0q, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .simm32, .none } },
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .to_mut_gpr, .immut_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .{ .rc = .general_purpose } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .dst1d, .dst1d, ._, ._ },
                        .{ ._, ._, .mov, .dst0q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .sub, .src0q, .src1q, ._, ._ },
                        .{ ._, ._c, .set, .dst1b, ._, ._, ._ },
                        .{ ._, ._, .@"and", .dst0q, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .to_mut_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .{ .ref = .src1 } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .sub, .src0q, .src1q, ._, ._ },
                        .{ ._, ._c, .set, .dst1b, ._, ._, ._ },
                        .{ ._, ._, .@"and", .dst0q, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 64 } },
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .none },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(2, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -16), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -16), .tmp1q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -16), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -16), ._, ._ },
                        .{ ._, ._o, .set, .mema(.dst0b, .add_src0_size), ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp1q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .c } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp1q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .ui(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 128 } },
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 128 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .o } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp1q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 128 } },
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 128 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .c } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memsia(.src1q, .@"8", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_src0_size), .tmp1q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } },
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .o } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(2, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -16), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -16), .tmp1q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -16), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -16), ._, ._ },
                        .{ ._, ._l, .ro, .tmp1q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp1q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._r, .ro, .tmp0q, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .none },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(2, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -16), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -16), .tmp1q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -16), ._, ._ },
                        .{ ._, ._c, .set, .mema(.dst0b, .add_src0_size), ._, ._, ._ },
                        .{ ._, ._, .bzhi, .tmp0q, .tmp1q, .tmp0q, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .ui(0), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .none },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(2, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -16), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -16), .tmp1q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -16), ._, ._ },
                        .{ ._, ._c, .set, .mema(.dst0b, .add_src0_size), ._, ._, ._ },
                        .{ ._, ._, .@"and", .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .ui(0), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } },
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .o } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp1q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._l, .ro, .tmp1q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .ro, .tmp0q, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .none },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp1q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._c, .set, .mema(.dst0b, .add_src0_size), ._, ._, ._ },
                        .{ ._, ._, .bzhi, .tmp0q, .tmp1q, .tmp0q, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .none },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp1q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._c, .set, .mema(.dst0b, .add_src0_size), ._, ._, ._ },
                        .{ ._, ._, .@"and", .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f} {f}", .{
                        @tagName(air_tag),
                        ty_pl.ty.toType().fmt(pt),
                        ops[0].tracking(cg),
                        ops[1].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].withOverflow(&res[1], cg);
                try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
            },
            .mul_with_overflow => |air_tag| {
                const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
                const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data;
                var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                var res: [2]Temp = undefined;
                cg.select(&res, &.{ ty_pl.ty.toType(), .u1 }, &ops, comptime &.{ .{
                    .src_constraints = .{ .{ .exact_signed_int = 8 }, .{ .exact_signed_int = 8 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .al }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .al }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .al }, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .i_, .mul, .src1b, ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_unsigned_int = 8 }, .{ .exact_unsigned_int = 8 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .al }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .al }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .al }, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mul, .src1b, ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .al }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .al }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .al }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .ne } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .i_, .mul, .src1b, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._l, .sa, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .cmp, .dst0w, .tmp0w, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .al }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .al }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .al }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .nbe } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mul, .src1b, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._, .@"and", .dst0b, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .cmp, .tmp0w, .ua(.src0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_signed_int = 16 }, .{ .exact_signed_int = 16 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .imm16, .none } },
                        .{ .src = .{ .imm16, .mem, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_gpr, .imm16, .none } },
                        .{ .src = .{ .imm16, .to_gpr, .none }, .commute = .{ 0, 1 } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .{ .cc = .c } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .i_, .mul, .dst0w, .src0w, .src1w, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_signed_int = 16 }, .{ .exact_signed_int = 16 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .i_, .mul, .dst0w, .src1w, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_unsigned_int = 16 }, .{ .exact_unsigned_int = 16 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .ax }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .ax }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .ax }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .reg = .dx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .mul, .src1w, ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .ax }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .ax }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .ax }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i32, .kind = .{ .reg = .edx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .ne } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, .i_, .mul, .src1w, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp0d, .ui(16), ._, ._ },
                        .{ ._, ._, .mov, .tmp0w, .dst0w, ._, ._ },
                        .{ ._, ._l, .sa, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .cmp, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .ax }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .ax }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .ax }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .reg = .dx } },
                        .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .mul, .src1w, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ },
                        .{ ._, ._, .@"and", .dst0w, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1w, .sa(.src0, .add_2_smin), ._, ._ },
                        .{ ._, ._, .@"or", .tmp1w, .tmp0w, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .ax }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .ax }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .ax }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .reg = .dx } },
                        .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .mul, .src1w, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ },
                        .{ ._, ._, .@"and", .dst0d, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1d, .uia(std.math.maxInt(u16), .src0, .sub_umax), ._, ._ },
                        .{ ._, ._, .@"or", .tmp1d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_signed_int = 32 }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .imm32, .none } },
                        .{ .src = .{ .imm32, .mem, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_gpr, .imm32, .none } },
                        .{ .src = .{ .imm32, .to_gpr, .none }, .commute = .{ 0, 1 } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .{ .cc = .c } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .i_, .mul, .dst0d, .src0d, .src1d, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_signed_int = 32 }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .i_, .mul, .dst0d, .src1d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .{ .exact_unsigned_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .eax }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .eax }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .eax }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .reg = .edx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mul, .src1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .eax }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .eax }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .eax }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i32, .kind = .{ .reg = .edx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .ne } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .i_, .mul, .src1d, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp0q, .ui(32), ._, ._ },
                        .{ ._, ._, .@"or", .tmp0q, .dst0q, ._, ._ },
                        .{ ._, ._l, .sa, .dst0q, .uia(64, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .dst0q, .uia(64, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .cmp, .dst0q, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .eax }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .eax }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .eax }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .ref = .src0 } },
                        .{ .type = .u32, .kind = .{ .reg = .edx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } }, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mul, .src1d, ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .@"and", .dst0d, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .@"or", .tmp0d, .tmp1d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 64 }, .{ .exact_signed_int = 64 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .simm32, .none } },
                        .{ .src = .{ .simm32, .mem, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_gpr, .simm32, .none } },
                        .{ .src = .{ .simm32, .to_gpr, .none }, .commute = .{ 0, 1 } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .{ .cc = .c } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .i_, .mul, .dst0q, .src0q, .src1d, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 64 }, .{ .exact_signed_int = 64 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .i_, .mul, .dst0q, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .{ .exact_unsigned_int = 64 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .eax }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .eax }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .eax }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mul, .src1q, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .rax }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .rax }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .rax }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .reg = .rdx } },
                        .{ .type = .i64, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .i_, .mul, .src1q, ._, ._, ._ },
                        .{ ._, ._, .sbb, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .dst0q, ._, ._ },
                        .{ ._, ._l, .sa, .dst0q, .uia(64, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .dst0q, .uia(64, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .dst0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp1q, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .rax }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .rax }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .rax }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .ref = .src0 } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } }, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mul, .src1q, ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .ua(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .bzhi, .dst0q, .tmp0q, .dst0q, ._ },
                        .{ ._, ._, .xor, .tmp0q, .dst0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp0q, .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .rax }, .mem, .none } },
                        .{ .src = .{ .mem, .{ .to_reg = .rax }, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .{ .to_reg = .rax }, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .ref = .src0 } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } }, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mul, .src1q, ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .@"and", .dst0q, .tmp0q, ._, ._ },
                        .{ ._, ._, .xor, .tmp0q, .dst0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp0q, .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, .slow_incdec, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 128 } },
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 128 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp8q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._nz, .cmov, .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 128 } },
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 128 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp8q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._nz, .cmov, .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 128 } },
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 128 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 128 } },
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 128 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, .slow_incdec, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 64 } },
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp8q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._nz, .cmov, .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_src0_size, -16), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 64 } },
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp8q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._nz, .cmov, .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_src0_size, -16), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 64 } },
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_src0_size, -16), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 64 } },
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_src0_size, -16), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, .slow_incdec, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } },
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp8q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._nz, .cmov, .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_src0_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp0q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } },
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp8q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._nz, .cmov, .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_src0_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp0q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } },
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_src0_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp0q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } },
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_src0_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp0q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, .slow_incdec, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } },
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp8q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._nz, .cmov, .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } },
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp8q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._nz, .cmov, .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } },
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } },
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mul, .tmp6q, ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), .tmp9q, ._, ._ },
                        .{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ },
                        .{ ._, ._e, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2q, .memad(.src1, .add_size, -8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0q, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                        .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ },
                        .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ },
                        .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp8q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ },
                        .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, .adx, null },
                    .src_constraints = .{
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 128 } },
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 128 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .isize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ .@"0:", ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._z, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp5p, .leaad(.tmp0, .sub_src0_size, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ .@"1:", ._x, .mul, .tmp8q, .tmp7q, .leai(.tmp1q, .tmp5), ._ },
                        .{ ._, ._x, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memiad(.dst0q, .tmp5, .add_src0_size, -8), .tmp7q, ._, ._ },
                        .{ ._, ._rcxz, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._x, .ado, .tmp8q, .memia(.dst0q, .tmp5, .add_src0_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ ._, ._, .lea, .tmp5p, .lead(.tmp5, 8), ._, ._ },
                        .{ ._, ._mp, .j, .@"1b", ._, ._, ._ },
                        .{ .@"2:", ._, .mov, .memi(.dst0q, .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp4d, .tmp0d, ._, ._ },
                        .{ ._, ._x, .ado, .tmp8q, .tmp3q, ._, ._ },
                        .{ ._, ._x, .adc, .tmp8q, .tmp3q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp8q, .leaid(.tmp1q, .tmp4, 8), ._, ._ },
                        .{ .@"2:", ._, .sub, .tmp4d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .@"test", .tmp2q, .tmp2q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, .slow_incdec, null },
                    .src_constraints = .{
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 128 } },
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 128 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ },
                        .{ .@"2:", ._x, .mul, .tmp8q, .tmp7q, .leasi(.tmp1q, .@"8", .tmp3), ._ },
                        .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), .tmp7q, ._, ._ },
                        .{ ._, ._c, .in, .tmp3p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp8q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp5q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ },
                        .{ .@"2:", ._, .sub, .tmp3d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp5q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .@"test", .tmp2q, .tmp2q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 128 } },
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 128 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ },
                        .{ .@"2:", ._x, .mul, .tmp8q, .tmp7q, .leasi(.tmp1q, .@"8", .tmp3), ._ },
                        .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), .tmp7q, ._, ._ },
                        .{ ._, ._c, .in, .tmp3p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp8q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp5q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp5q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .@"test", .tmp2q, .tmp2q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 128 } },
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 128 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp7q, .tmp4q, ._, ._ },
                        .{ ._, ._, .mul, .leasi(.tmp1q, .@"8", .tmp3), ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), .tmp7q, ._, ._ },
                        .{ ._, ._c, .in, .tmp3p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp8q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp8q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ },
                        .{ .@"2:", ._, .sub, .tmp3d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .@"test", .tmp2q, .tmp2q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 128 } },
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 128 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp7q, .tmp4q, ._, ._ },
                        .{ ._, ._, .mul, .leasi(.tmp1q, .@"8", .tmp3), ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), .tmp7q, ._, ._ },
                        .{ ._, ._c, .in, .tmp3p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp8q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp8q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .@"test", .tmp2q, .tmp2q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, .adx, null },
                    .src_constraints = .{
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .isize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ .@"0:", ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._z, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp5p, .leaad(.tmp0, .sub_src0_size, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ .@"1:", ._x, .mul, .tmp8q, .tmp7q, .leai(.tmp1q, .tmp5), ._ },
                        .{ ._, ._x, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memiad(.dst0q, .tmp5, .add_src0_size, -8), .tmp7q, ._, ._ },
                        .{ ._, ._rcxz, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._x, .ado, .tmp8q, .memia(.dst0q, .tmp5, .add_src0_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ ._, ._, .lea, .tmp5p, .lead(.tmp5, 8), ._, ._ },
                        .{ ._, ._mp, .j, .@"1b", ._, ._, ._ },
                        .{ .@"2:", ._, .mov, .memi(.dst0q, .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp4d, .tmp0d, ._, ._ },
                        .{ ._, ._x, .ado, .tmp8q, .tmp3q, ._, ._ },
                        .{ ._, ._x, .adc, .tmp8q, .tmp3q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp8q, .leaid(.tmp1q, .tmp4, 8), ._, ._ },
                        .{ .@"2:", ._, .sub, .tmp4d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .ui(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, .slow_incdec, null },
                    .src_constraints = .{
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ },
                        .{ .@"2:", ._x, .mul, .tmp8q, .tmp7q, .leasi(.tmp1q, .@"8", .tmp3), ._ },
                        .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), .tmp7q, ._, ._ },
                        .{ ._, ._c, .in, .tmp3p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp8q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp5q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ },
                        .{ .@"2:", ._, .sub, .tmp3d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp5q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .ui(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ },
                        .{ .@"2:", ._x, .mul, .tmp8q, .tmp7q, .leasi(.tmp1q, .@"8", .tmp3), ._ },
                        .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), .tmp7q, ._, ._ },
                        .{ ._, ._c, .in, .tmp3p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp8q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp5q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp5q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .ui(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp7q, .tmp4q, ._, ._ },
                        .{ ._, ._, .mul, .leasi(.tmp1q, .@"8", .tmp3), ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), .tmp7q, ._, ._ },
                        .{ ._, ._c, .in, .tmp3p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp8q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp8q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ },
                        .{ .@"2:", ._, .sub, .tmp3d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .ui(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp7q, .tmp4q, ._, ._ },
                        .{ ._, ._, .mul, .leasi(.tmp1q, .@"8", .tmp3), ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), .tmp7q, ._, ._ },
                        .{ ._, ._c, .in, .tmp3p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp8q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp8q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .ui(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, .adx, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .isize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ .@"0:", ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._z, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp5p, .leaad(.tmp0, .sub_src0_size, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ .@"1:", ._x, .mul, .tmp8q, .tmp7q, .leai(.tmp1q, .tmp5), ._ },
                        .{ ._, ._x, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memiad(.dst0q, .tmp5, .add_src0_size, -8), .tmp7q, ._, ._ },
                        .{ ._, ._rcxz, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._x, .ado, .tmp8q, .memia(.dst0q, .tmp5, .add_src0_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ ._, ._, .lea, .tmp5p, .lead(.tmp5, 8), ._, ._ },
                        .{ ._, ._mp, .j, .@"1b", ._, ._, ._ },
                        .{ .@"2:", ._, .mov, .memi(.dst0q, .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp4d, .tmp0d, ._, ._ },
                        .{ ._, ._x, .ado, .tmp8q, .tmp3q, ._, ._ },
                        .{ ._, ._x, .adc, .tmp8q, .tmp3q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp8q, .leaid(.tmp1q, .tmp4, 8), ._, ._ },
                        .{ .@"2:", ._, .sub, .tmp4d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.dst0q, .add_src0_size, -16), ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .bzhi, .tmp0q, .tmp1q, .tmp0q, ._ },
                        .{ ._, ._r, .sh, .tmp1q, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .ui(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, .slow_incdec, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ },
                        .{ .@"2:", ._x, .mul, .tmp8q, .tmp7q, .leasi(.tmp1q, .@"8", .tmp3), ._ },
                        .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), .tmp7q, ._, ._ },
                        .{ ._, ._c, .in, .tmp3p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp8q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp5q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ },
                        .{ .@"2:", ._, .sub, .tmp3d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp5q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.dst0q, .add_src0_size, -16), ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .bzhi, .tmp0q, .tmp1q, .tmp0q, ._ },
                        .{ ._, ._r, .sh, .tmp1q, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .ui(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ },
                        .{ .@"2:", ._x, .mul, .tmp8q, .tmp7q, .leasi(.tmp1q, .@"8", .tmp3), ._ },
                        .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), .tmp7q, ._, ._ },
                        .{ ._, ._c, .in, .tmp3p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp8q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp5q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp5q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.dst0q, .add_src0_size, -16), ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .bzhi, .tmp0q, .tmp1q, .tmp0q, ._ },
                        .{ ._, ._r, .sh, .tmp1q, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .ui(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp7q, .tmp4q, ._, ._ },
                        .{ ._, ._, .mul, .leasi(.tmp1q, .@"8", .tmp3), ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), .tmp7q, ._, ._ },
                        .{ ._, ._c, .in, .tmp3p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp8q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp8q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ },
                        .{ .@"2:", ._, .sub, .tmp3d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.dst0q, .add_src0_size, -16), ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp1q, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .ui(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp7q, .tmp4q, ._, ._ },
                        .{ ._, ._, .mul, .leasi(.tmp1q, .@"8", .tmp3), ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), .tmp7q, ._, ._ },
                        .{ ._, ._c, .in, .tmp3p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp8q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp8q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.dst0q, .add_src0_size, -16), ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp1q, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .ui(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, .adx, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .isize, .kind = .{ .reg = .rcx } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ .@"0:", ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._z, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp5p, .leaad(.tmp0, .sub_src0_size, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ .@"1:", ._x, .mul, .tmp8q, .tmp7q, .leai(.tmp1q, .tmp5), ._ },
                        .{ ._, ._x, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memiad(.dst0q, .tmp5, .add_src0_size, -8), .tmp7q, ._, ._ },
                        .{ ._, ._rcxz, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._x, .ado, .tmp8q, .memia(.dst0q, .tmp5, .add_src0_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ ._, ._, .lea, .tmp5p, .lead(.tmp5, 8), ._, ._ },
                        .{ ._, ._mp, .j, .@"1b", ._, ._, ._ },
                        .{ .@"2:", ._, .mov, .memi(.dst0q, .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp4d, .tmp0d, ._, ._ },
                        .{ ._, ._x, .ado, .tmp8q, .tmp3q, ._, ._ },
                        .{ ._, ._x, .adc, .tmp8q, .tmp3q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp8q, .leaid(.tmp1q, .tmp4, 8), ._, ._ },
                        .{ .@"2:", ._, .sub, .tmp4d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .bzhi, .tmp0q, .tmp1q, .tmp0q, ._ },
                        .{ ._, ._r, .sh, .tmp1q, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, .slow_incdec, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ },
                        .{ .@"2:", ._x, .mul, .tmp8q, .tmp7q, .leasi(.tmp1q, .@"8", .tmp3), ._ },
                        .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), .tmp7q, ._, ._ },
                        .{ ._, ._c, .in, .tmp3p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp8q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp5q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ },
                        .{ .@"2:", ._, .sub, .tmp3d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp5q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .bzhi, .tmp0q, .tmp1q, .tmp0q, ._ },
                        .{ ._, ._r, .sh, .tmp1q, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ },
                        .{ .@"2:", ._x, .mul, .tmp8q, .tmp7q, .leasi(.tmp1q, .@"8", .tmp3), ._ },
                        .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), .tmp7q, ._, ._ },
                        .{ ._, ._c, .in, .tmp3p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp8q, ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp5q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp5q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .bzhi, .tmp0q, .tmp1q, .tmp0q, ._ },
                        .{ ._, ._r, .sh, .tmp1q, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp7q, .tmp4q, ._, ._ },
                        .{ ._, ._, .mul, .leasi(.tmp1q, .@"8", .tmp3), ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), .tmp7q, ._, ._ },
                        .{ ._, ._c, .in, .tmp3p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp8q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp8q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ },
                        .{ .@"2:", ._, .sub, .tmp3d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp1q, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                        .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), ._, ._ },
                        .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp7q, .tmp4q, ._, ._ },
                        .{ ._, ._, .mul, .leasi(.tmp1q, .@"8", .tmp3), ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ },
                        .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), .tmp7q, ._, ._ },
                        .{ ._, ._c, .in, .tmp3p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ },
                        .{ ._, ._, .adc, .tmp8q, .si(0), ._, ._ },
                        .{ ._, ._mp, .j, .@"2f", ._, ._, ._ },
                        .{ .@"1:", ._, .@"or", .tmp8q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ },
                        .{ .@"2:", ._c, .de, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp1q, .ua(.src0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp2q, .tmp1q, ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f} {f}", .{
                        @tagName(air_tag),
                        ty_pl.ty.toType().fmt(pt),
                        ops[0].tracking(cg),
                        ops[1].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].withOverflow(&res[1], cg);
                try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
            },
            .shl_with_overflow => |air_tag| {
                const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
                const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data;
                var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                var res: [2]Temp = undefined;
                cg.select(&res, &.{ ty_pl.ty.toType(), .u1 }, &ops, comptime &.{ .{
                    .src_constraints = .{ .{ .exact_signed_int = 8 }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .{ .imm = 1 }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._l, .sa, .dst0b, .src1b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_unsigned_int = 8 }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .{ .imm = 1 }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._l, .sh, .dst0b, .src1b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_signed_int = 8 }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = 1 }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0b, .src0b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_unsigned_int = 8 }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = 1 }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0b, .src0b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .byte }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .imm8, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .{ .cc = .ne } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0b, .uia(8, .src0, .add_src1_sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0b, .uia(8, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0b, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .tmp0b, .src0b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .imm8, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .{ .cc = .nbe } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0d, .src0d, ._, ._ },
                        .{ ._, ._, .@"and", .dst0b, .ua(.src0, .add_umax_shr_src1), ._, ._ },
                        .{ ._, ._l, .sh, .dst0b, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .src0b, .ua(.src0, .add_umax_shr_src1), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_signed_int = 8 }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .{ .cc = .ne } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0b, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0b, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .tmp0b, .src0b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_unsigned_int = 8 }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .{ .cc = .ne } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._l, .sh, .tmp0b, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0b, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .tmp0b, .src0b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .byte }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .{ .cc = .ne } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0b, .src1b, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0b, .uia(8, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0b, .uia(8, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0b, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .tmp0b, .src0b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .{ .cc = .ne } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._l, .sh, .tmp0b, .src1b, ._, ._ },
                        .{ ._, ._, .@"and", .tmp0b, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0b, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .tmp0b, .src0b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_signed_int = 16 }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .{ .imm = 1 }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._l, .sa, .dst0w, .src1b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_unsigned_int = 16 }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .{ .imm = 1 }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._l, .sh, .dst0w, .src1b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_signed_int = 8 }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = 1 }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0w, .src0w, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_unsigned_int = 8 }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = 1 }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0w, .src0w, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .imm8, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .{ .cc = .ne } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0d, .uia(32, .src0, .add_src1_sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0d, .uia(32, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .tmp0w, .src0w, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .imm8, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .{ .cc = .nbe } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0d, .src0d, ._, ._ },
                        .{ ._, ._, .@"and", .dst0w, .ua(.src0, .add_umax_shr_src1), ._, ._ },
                        .{ ._, ._l, .sh, .dst0d, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .src0w, .ua(.src0, .add_umax_shr_src1), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .imm8, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .{ .cc = .nbe } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0d, .src0d, ._, ._ },
                        .{ ._, ._, .@"and", .dst0d, .ua(.src0, .add_umax_shr_src1), ._, ._ },
                        .{ ._, ._l, .sh, .dst0d, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .src0w, .ua(.src0, .add_umax_shr_src1), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_signed_int = 16 }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .{ .cc = .ne } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0w, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .tmp0w, .src0w, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_unsigned_int = 16 }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .{ .cc = .ne } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._l, .sh, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0w, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .tmp0w, .src0w, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .{ .cc = .ne } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0d, .uia(32, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0d, .uia(32, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .tmp0w, .src0w, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .{ .cc = .ne } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._l, .sh, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .@"and", .tmp0d, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .tmp0w, .src0w, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_signed_int = 32 }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .{ .imm = 1 }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._l, .sa, .dst0d, .src1b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .{ .imm = 1 }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._l, .sh, .dst0d, .src1b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_signed_int = 32 }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = 1 }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0d, .src0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = 1 }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0d, .src0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .dword }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .imm8, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .{ .cc = .ne } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0d, .uia(32, .src0, .add_src1_sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0d, .uia(32, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .tmp0d, .src0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .imm8, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .{ .cc = .nbe } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0d, .src0d, ._, ._ },
                        .{ ._, ._, .@"and", .dst0d, .ua(.src0, .add_umax_shr_src1), ._, ._ },
                        .{ ._, ._l, .sh, .dst0d, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .src0d, .ua(.src0, .add_umax_shr_src1), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_signed_int = 32 }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .{ .cc = .ne } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .tmp0d, .src0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .{ .cc = .ne } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._l, .sh, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .tmp0d, .src0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .dword }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .{ .cc = .ne } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0d, .uia(32, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0d, .uia(32, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .tmp0d, .src0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .{ .cc = .ne } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._l, .sh, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .@"and", .tmp0d, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .tmp0d, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 64 }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .{ .imm = 1 }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._l, .sa, .dst0q, .src1b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .{ .imm = 1 }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._l, .sh, .dst0q, .src1b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 64 }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = 1 }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0q, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = 1 }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0q, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .imm8, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .{ .cc = .ne } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0q, .uia(64, .src0, .add_src1_sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .dst0q, .tmp0q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .tmp0q, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .imm8, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .{ .cc = .nbe } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax_shr_src1), ._, ._ },
                        .{ ._, ._, .mov, .dst0q, .src0q, ._, ._ },
                        .{ ._, ._, .@"and", .dst0q, .tmp0q, ._, ._ },
                        .{ ._, ._l, .sh, .dst0q, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .src0q, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 64 }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .{ .cc = .ne } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0q, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .dst0q, .tmp0q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .tmp0q, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .{ .cc = .ne } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ },
                        .{ ._, ._l, .sh, .tmp0q, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .dst0q, .tmp0q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0q, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .tmp0q, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .{ .cc = .ne } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0q, .src1b, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .dst0q, .tmp0q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .tmp0q, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .{ .cc = .ne } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ },
                        .{ ._, ._l, .sh, .tmp0q, .src1b, ._, ._ },
                        .{ ._, ._, .@"and", .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .dst0q, .tmp0q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0q, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .tmp0q, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 128 } },
                        .{ .unsigned_int = .byte },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp5q, .tmp4q, .src1b, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .leasi(.tmp2q, .@"8", .tmp6), ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._, .sub, .tmp6d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp6q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp6q, ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp4q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._r, .sa, .tmp7q, .ui(63), ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 128 } },
                        .{ .unsigned_int = .byte },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp5q, .tmp4q, .src1b, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .leasi(.tmp2q, .@"8", .tmp6), ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._c, .de, .tmp6d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._s, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp6q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp6q, ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp4q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._r, .sa, .tmp7q, .ui(63), ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 128 } },
                        .{ .unsigned_int = .word },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1w, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp5q, .tmp4q, .src1b, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .leasi(.tmp2q, .@"8", .tmp6), ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._, .sub, .tmp6d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp6q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp6q, ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp4q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._r, .sa, .tmp7q, .ui(63), ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 128 } },
                        .{ .unsigned_int = .word },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1w, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp5q, .tmp4q, .src1b, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .leasi(.tmp2q, .@"8", .tmp6), ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._c, .de, .tmp6d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._s, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp6q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp6q, ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp4q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._r, .sa, .tmp7q, .ui(63), ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 128 } },
                        .{ .unsigned_int = .byte },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .@"or", .tmp4q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .sub, .tmp5d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp5q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .@"test", .tmp4q, .tmp4q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 128 } },
                        .{ .unsigned_int = .byte },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .@"or", .tmp4q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._s, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp5q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .@"test", .tmp4q, .tmp4q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 128 } },
                        .{ .unsigned_int = .word },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1w, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .@"or", .tmp4q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .sub, .tmp5d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp5q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .@"test", .tmp4q, .tmp4q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 128 } },
                        .{ .unsigned_int = .word },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1w, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .@"or", .tmp4q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._s, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp5q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .@"test", .tmp4q, .tmp4q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 64 } },
                        .{ .unsigned_int = .byte },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp5q, .tmp4q, .src1b, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .leasi(.tmp2q, .@"8", .tmp6), ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._, .sub, .tmp6d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp6q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp6q, ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp4q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .memad(.dst0q, .add_src0_size, -16), ._, ._ },
                        .{ ._, ._r, .sa, .tmp7q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp7q, ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 64 } },
                        .{ .unsigned_int = .byte },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp5q, .tmp4q, .src1b, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .leasi(.tmp2q, .@"8", .tmp6), ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._c, .de, .tmp6d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._s, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp6q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp6q, ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp4q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .memad(.dst0q, .add_src0_size, -16), ._, ._ },
                        .{ ._, ._r, .sa, .tmp7q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp7q, ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 64 } },
                        .{ .unsigned_int = .word },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1w, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp5q, .tmp4q, .src1b, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .leasi(.tmp2q, .@"8", .tmp6), ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._, .sub, .tmp6d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp6q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp6q, ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp4q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .memad(.dst0q, .add_src0_size, -16), ._, ._ },
                        .{ ._, ._r, .sa, .tmp7q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp7q, ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 64 } },
                        .{ .unsigned_int = .word },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1w, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp5q, .tmp4q, .src1b, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .leasi(.tmp2q, .@"8", .tmp6), ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._c, .de, .tmp6d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._s, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp6q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp6q, ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp4q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .memad(.dst0q, .add_src0_size, -16), ._, ._ },
                        .{ ._, ._r, .sa, .tmp7q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp7q, ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .{ .unsigned_int = .byte },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp4q, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .@"or", .tmp4q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .sub, .tmp5d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp5q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .@"test", .tmp4q, .tmp4q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .{ .unsigned_int = .byte },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp4q, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .@"or", .tmp4q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._s, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp5q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .@"test", .tmp4q, .tmp4q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .{ .unsigned_int = .word },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1w, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp4q, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .@"or", .tmp4q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .sub, .tmp5d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp5q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .@"test", .tmp4q, .tmp4q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .{ .unsigned_int = .word },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1w, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp4q, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .@"or", .tmp4q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._s, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp5q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .@"test", .tmp4q, .tmp4q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } },
                        .{ .unsigned_int = .byte },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp5q, .tmp4q, .src1b, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .leasi(.tmp2q, .@"8", .tmp6), ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._, .sub, .tmp6d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp6q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp6q, ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp4q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memad(.dst0q, .add_src0_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp6q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp6q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp6q, ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp6q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp6q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } },
                        .{ .unsigned_int = .byte },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp5q, .tmp4q, .src1b, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .leasi(.tmp2q, .@"8", .tmp6), ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._c, .de, .tmp6d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._s, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp6q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp6q, ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp4q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memad(.dst0q, .add_src0_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp6q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp6q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp6q, ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp6q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp6q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } },
                        .{ .unsigned_int = .word },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1w, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp5q, .tmp4q, .src1b, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .leasi(.tmp2q, .@"8", .tmp6), ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._, .sub, .tmp6d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp6q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp6q, ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp4q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memad(.dst0q, .add_src0_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp6q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp6q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp6q, ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp6q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp6q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } },
                        .{ .unsigned_int = .word },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1w, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp5q, .tmp4q, .src1b, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .leasi(.tmp2q, .@"8", .tmp6), ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._c, .de, .tmp6d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._s, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp6q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp6q, ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp4q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memad(.dst0q, .add_src0_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp6q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp6q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp6q, ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp6q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp6q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi, .slow_incdec, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .{ .unsigned_int = .byte },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp4q, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .@"or", .tmp4q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .sub, .tmp5d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp5q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.dst0q, .add_src0_size, -16), ._, ._ },
                        .{ ._, ._, .andn, .tmp5q, .tmp2q, .tmp3q, ._ },
                        .{ ._, ._, .@"and", .tmp2q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp2q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .{ .unsigned_int = .byte },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp4q, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .@"or", .tmp4q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._s, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp5q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.dst0q, .add_src0_size, -16), ._, ._ },
                        .{ ._, ._, .andn, .tmp5q, .tmp2q, .tmp3q, ._ },
                        .{ ._, ._, .@"and", .tmp2q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp2q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .{ .unsigned_int = .byte },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp4q, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .@"or", .tmp4q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .sub, .tmp5d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp5q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -16), ._, ._ },
                        .{ ._, ._, .@"and", .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .{ .unsigned_int = .byte },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp4q, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .@"or", .tmp4q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._s, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp5q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -16), ._, ._ },
                        .{ ._, ._, .@"and", .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi, .slow_incdec, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .{ .unsigned_int = .word },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1w, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp4q, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .@"or", .tmp4q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .sub, .tmp5d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp5q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.dst0q, .add_src0_size, -16), ._, ._ },
                        .{ ._, ._, .andn, .tmp5q, .tmp2q, .tmp3q, ._ },
                        .{ ._, ._, .@"and", .tmp2q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp2q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .{ .unsigned_int = .word },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1w, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp4q, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .@"or", .tmp4q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._s, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp5q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.dst0q, .add_src0_size, -16), ._, ._ },
                        .{ ._, ._, .andn, .tmp5q, .tmp2q, .tmp3q, ._ },
                        .{ ._, ._, .@"and", .tmp2q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp2q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .{ .unsigned_int = .word },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1w, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp4q, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .@"or", .tmp4q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .sub, .tmp5d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp5q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -16), ._, ._ },
                        .{ ._, ._, .@"and", .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .{ .unsigned_int = .word },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1w, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp4q, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .@"or", .tmp4q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._s, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp5q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -16), ._, ._ },
                        .{ ._, ._, .@"and", .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } },
                        .{ .unsigned_int = .byte },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp5q, .tmp4q, .src1b, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .leasi(.tmp2q, .@"8", .tmp6), ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._, .sub, .tmp6d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp6q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp6q, ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp4q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp6q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp6q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp6q, ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp6q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } },
                        .{ .unsigned_int = .byte },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp5q, .tmp4q, .src1b, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .leasi(.tmp2q, .@"8", .tmp6), ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._c, .de, .tmp6d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._s, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp6q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp6q, ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp4q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp6q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp6q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp6q, ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp6q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } },
                        .{ .unsigned_int = .word },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1w, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp5q, .tmp4q, .src1b, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .leasi(.tmp2q, .@"8", .tmp6), ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._, .sub, .tmp6d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp6q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp6q, ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp4q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp6q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp6q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp6q, ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp6q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } },
                        .{ .unsigned_int = .word },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1w, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp5q, .tmp4q, .src1b, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .leasi(.tmp2q, .@"8", .tmp6), ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._c, .de, .tmp6d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._s, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp6q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp6q, ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp4q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp6q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp6q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp6q, ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp6q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi, .slow_incdec, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .{ .unsigned_int = .byte },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .@"or", .tmp4q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .sub, .tmp5d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp5q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .andn, .tmp5q, .tmp2q, .tmp3q, ._ },
                        .{ ._, ._, .@"and", .tmp2q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp2q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .{ .unsigned_int = .byte },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .@"or", .tmp4q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._s, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp5q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .andn, .tmp5q, .tmp2q, .tmp3q, ._ },
                        .{ ._, ._, .@"and", .tmp2q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp2q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .{ .unsigned_int = .byte },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .@"or", .tmp4q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .sub, .tmp5d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp5q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .@"and", .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .{ .unsigned_int = .byte },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .@"or", .tmp4q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._s, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp5q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .@"and", .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi, .slow_incdec, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .{ .unsigned_int = .word },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1w, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .@"or", .tmp4q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .sub, .tmp5d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp5q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .andn, .tmp5q, .tmp2q, .tmp3q, ._ },
                        .{ ._, ._, .@"and", .tmp2q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp2q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .{ .unsigned_int = .word },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1w, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .@"or", .tmp4q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._s, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp5q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .andn, .tmp5q, .tmp2q, .tmp3q, ._ },
                        .{ ._, ._, .@"and", .tmp2q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp2q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .{ .unsigned_int = .word },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1w, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .@"or", .tmp4q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .sub, .tmp5d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp5q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .@"and", .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .{ .unsigned_int = .word },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .{ .cc = .nz } },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1w, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .@"or", .tmp4q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._s, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp5q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .@"and", .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f} {f}", .{
                        @tagName(air_tag),
                        ty_pl.ty.toType().fmt(pt),
                        ops[0].tracking(cg),
                        ops[1].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].withOverflow(&res[1], cg);
                try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
            },
            .alloc => {
                const ty = air_datas[@intFromEnum(inst)].ty;
                const slot = try cg.tempInit(ty, .{ .lea_frame = .{
                    .index = try cg.allocMemPtr(inst),
                } });
                try slot.finish(inst, &.{}, &.{}, cg);
            },
            .inferred_alloc, .inferred_alloc_comptime => unreachable,
            .ret_ptr => {
                const ty = air_datas[@intFromEnum(inst)].ty;
                var slot = switch (cg.ret_mcv.long) {
                    else => unreachable,
                    .none => try cg.tempInit(ty, .{ .lea_frame = .{
                        .index = try cg.allocMemPtr(inst),
                    } }),
                    .load_frame => slot: {
                        var slot = try cg.tempInit(ty, cg.ret_mcv.long);
                        try slot.toOffset(cg.ret_mcv.short.indirect.off, cg);
                        break :slot slot;
                    },
                };
                try slot.finish(inst, &.{}, &.{}, cg);
            },
            .assembly => try cg.airAsm(inst),
            .bit_and, .bit_or, .xor, .bool_and, .bool_or => |air_tag| {
                const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                var res: [1]Temp = undefined;
                cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, switch (@as(Mir.Inst.Tag, switch (air_tag) {
                    else => unreachable,
                    .bit_and, .bool_and => .@"and",
                    .bit_or, .bool_or => .@"or",
                    .xor => .xor,
                })) {
                    else => unreachable,
                    inline .@"and", .@"or", .xor => |mir_tag| comptime &.{ .{
                        .src_constraints = .{ .{ .size = .byte }, .{ .size = .byte }, .any },
                        .patterns = &.{
                            .{ .src = .{ .mut_mem, .imm8, .none } },
                            .{ .src = .{ .imm8, .mut_mem, .none }, .commute = .{ 0, 1 } },
                            .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                            .{ .src = .{ .imm8, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                            .{ .src = .{ .mut_mem, .to_gpr, .none } },
                            .{ .src = .{ .to_gpr, .mut_mem, .none }, .commute = .{ 0, 1 } },
                            .{ .src = .{ .to_mut_gpr, .mem, .none } },
                            .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                            .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, mir_tag, .dst0b, .src1b, ._, ._ },
                        } },
                    }, .{
                        .src_constraints = .{ .{ .size = .word }, .{ .size = .word }, .any },
                        .patterns = &.{
                            .{ .src = .{ .mut_mem, .imm16, .none } },
                            .{ .src = .{ .imm16, .mut_mem, .none }, .commute = .{ 0, 1 } },
                            .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                            .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                            .{ .src = .{ .mut_mem, .to_gpr, .none } },
                            .{ .src = .{ .to_gpr, .mut_mem, .none }, .commute = .{ 0, 1 } },
                            .{ .src = .{ .to_mut_gpr, .mem, .none } },
                            .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                            .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, mir_tag, .dst0w, .src1w, ._, ._ },
                        } },
                    }, .{
                        .src_constraints = .{ .{ .size = .dword }, .{ .size = .dword }, .any },
                        .patterns = &.{
                            .{ .src = .{ .mut_mem, .imm32, .none } },
                            .{ .src = .{ .imm32, .mut_mem, .none }, .commute = .{ 0, 1 } },
                            .{ .src = .{ .to_mut_gpr, .imm32, .none } },
                            .{ .src = .{ .imm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                            .{ .src = .{ .mut_mem, .to_gpr, .none } },
                            .{ .src = .{ .to_gpr, .mut_mem, .none }, .commute = .{ 0, 1 } },
                            .{ .src = .{ .to_mut_gpr, .mem, .none } },
                            .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                            .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, mir_tag, .dst0d, .src1d, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .@"64bit", null, null, null },
                        .src_constraints = .{ .{ .size = .qword }, .{ .size = .qword }, .any },
                        .patterns = &.{
                            .{ .src = .{ .mut_mem, .simm32, .none } },
                            .{ .src = .{ .simm32, .mut_mem, .none }, .commute = .{ 0, 1 } },
                            .{ .src = .{ .to_mut_gpr, .simm32, .none } },
                            .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                            .{ .src = .{ .mut_mem, .to_gpr, .none } },
                            .{ .src = .{ .to_gpr, .mut_mem, .none }, .commute = .{ 0, 1 } },
                            .{ .src = .{ .to_mut_gpr, .mem, .none } },
                            .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                            .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, mir_tag, .dst0q, .src1q, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .mmx, null, null, null },
                        .src_constraints = .{ .{ .size = .qword }, .{ .size = .qword }, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_mmx, .mem, .none } },
                            .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } },
                            .{ .src = .{ .to_mut_mmx, .to_mmx, .none } },
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_, mir_tag, .dst0q, .src1q, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .src_constraints = .{ .{ .size = .xword }, .{ .size = .xword }, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .mem, .none } },
                            .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                            .{ .src = .{ .to_sse, .to_sse, .none } },
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_, mir_tag, .dst0x, .src0x, .src1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .src_constraints = .{ .{ .size = .xword }, .{ .size = .xword }, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .mem, .none } },
                            .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                            .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_, mir_tag, .dst0x, .src1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .src_constraints = .{ .{ .size = .xword }, .{ .size = .xword }, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .mem, .none } },
                            .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                            .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, mir_tag, .dst0x, .src1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .src_constraints = .{ .{ .size = .yword }, .{ .size = .yword }, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .mem, .none } },
                            .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                            .{ .src = .{ .to_sse, .to_sse, .none } },
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_, mir_tag, .dst0y, .src0y, .src1y, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .src_constraints = .{ .{ .size = .yword }, .{ .size = .yword }, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .mem, .none } },
                            .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                            .{ .src = .{ .to_sse, .to_sse, .none } },
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_pd, mir_tag, .dst0y, .src0y, .src1y, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .src_constraints = .{ .{ .multiple_size = .yword }, .{ .multiple_size = .yword }, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .to_mem, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                            .{ .@"0:", .v_dqu, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                            .{ ._, .vp_, mir_tag, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_size), ._ },
                            .{ ._, .v_dqu, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .src_constraints = .{ .{ .multiple_size = .yword }, .{ .multiple_size = .yword }, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .to_mem, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                            .{ .@"0:", .v_pd, .movu, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                            .{ ._, .v_pd, mir_tag, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_size), ._ },
                            .{ ._, .v_pd, .movu, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .src_constraints = .{ .{ .multiple_size = .xword }, .{ .multiple_size = .xword }, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .to_mem, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                            .{ .@"0:", .v_dqu, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                            .{ ._, .vp_, mir_tag, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._ },
                            .{ ._, .v_dqu, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .src_constraints = .{ .{ .multiple_size = .xword }, .{ .multiple_size = .xword }, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .to_mem, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                            .{ .@"0:", ._dqu, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                            .{ ._, .p_, mir_tag, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                            .{ ._, ._dqu, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .src_constraints = .{ .{ .multiple_size = .xword }, .{ .multiple_size = .xword }, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .to_mem, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                            .{ .@"0:", ._ps, .movu, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                            .{ ._, ._ps, mir_tag, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                            .{ ._, ._ps, .movu, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .mmx, null, null, null },
                        .src_constraints = .{ .{ .multiple_size = .qword }, .{ .multiple_size = .qword }, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .to_mem, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .kind = .{ .rc = .mmx } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                            .{ .@"0:", ._q, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ },
                            .{ ._, .p_, mir_tag, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ },
                            .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .src_constraints = .{ .{ .multiple_size = .qword }, .{ .multiple_size = .qword }, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .to_mem, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                            .{ .@"0:", ._, .mov, .tmp1p, .memia(.src0p, .tmp0, .add_size), ._, ._ },
                            .{ ._, ._, mir_tag, .tmp1p, .memia(.src1p, .tmp0, .add_size), ._, ._ },
                            .{ ._, ._, .mov, .memia(.dst0p, .tmp0, .add_size), .tmp1p, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .sa(.tmp1, .add_size), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    } },
                }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f} {f}", .{
                        @tagName(air_tag),
                        cg.typeOf(bin_op.lhs).fmt(pt),
                        ops[0].tracking(cg),
                        ops[1].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
            },
            .shr, .shr_exact => |air_tag| {
                const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                var res: [1]Temp = undefined;
                cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{
                    .src_constraints = .{ .{ .signed_int = .byte }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .imm8, .none } },
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                        .{ .src = .{ .mut_mem, .{ .to_reg = .cl }, .none } },
                        .{ .src = .{ .to_mut_gpr, .{ .to_reg = .cl }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._r, .sa, .dst0b, .src1b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .imm8, .none } },
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                        .{ .src = .{ .mut_mem, .{ .to_reg = .cl }, .none } },
                        .{ .src = .{ .to_mut_gpr, .{ .to_reg = .cl }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._r, .sh, .dst0b, .src1b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .exact_unsigned_int = 4 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .imm8, .none } },
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                        .{ .src = .{ .mut_mem, .{ .to_reg = .cl }, .none } },
                        .{ .src = .{ .to_mut_gpr, .{ .to_reg = .cl }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._r, .sa, .dst0w, .src1b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .exact_unsigned_int = 4 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .imm8, .none } },
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                        .{ .src = .{ .mut_mem, .{ .to_reg = .cl }, .none } },
                        .{ .src = .{ .to_mut_gpr, .{ .to_reg = .cl }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._r, .sh, .dst0w, .src1b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .dword }, .{ .exact_unsigned_int = 5 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .imm8, .none } },
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._r, .sa, .dst0d, .src1b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .exact_unsigned_int = 5 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .imm8, .none } },
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._r, .sh, .dst0d, .src1b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi2, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .dword }, .{ .exact_unsigned_int = 5 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .to_gpr, .none } },
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._rx, .sa, .dst0d, .src0d, .src1d, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi2, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .exact_unsigned_int = 5 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .to_gpr, .none } },
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._rx, .sh, .dst0d, .src0d, .src1d, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .dword }, .{ .exact_unsigned_int = 5 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .{ .to_reg = .cl }, .none } },
                        .{ .src = .{ .to_mut_gpr, .{ .to_reg = .cl }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._r, .sa, .dst0d, .src1b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .exact_unsigned_int = 5 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .{ .to_reg = .cl }, .none } },
                        .{ .src = .{ .to_mut_gpr, .{ .to_reg = .cl }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._r, .sh, .dst0d, .src1b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .{ .exact_unsigned_int = 6 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .imm8, .none } },
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._r, .sa, .dst0q, .src1b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .exact_unsigned_int = 6 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .imm8, .none } },
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._r, .sh, .dst0q, .src1b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, null, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .{ .exact_unsigned_int = 6 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .to_gpr, .none } },
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._rx, .sa, .dst0q, .src0q, .src1q, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .exact_unsigned_int = 6 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .to_gpr, .none } },
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._rx, .sh, .dst0q, .src0q, .src1q, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .{ .exact_unsigned_int = 6 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .{ .to_reg = .cl }, .none } },
                        .{ .src = .{ .to_mut_gpr, .{ .to_reg = .cl }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._r, .sa, .dst0q, .src1b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .exact_unsigned_int = 6 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .{ .to_reg = .cl }, .none } },
                        .{ .src = .{ .to_mut_gpr, .{ .to_reg = .cl }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._r, .sh, .dst0q, .src1b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } },
                        .{ .unsigned_int = .byte },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leasia(.none, .@"8", .tmp0, .sub_src0_size), ._, ._ },
                        .{ ._, ._, .not, .tmp0p, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsia(.dst0, .@"8", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memia(.src0q, .tmp1, .add_size), ._, ._ },
                        .{ ._, ._mp, .j, .@"1f", ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp4q, .memia(.src0q, .tmp1, .add_size), ._, ._ },
                        .{ ._, ._rd, .sh, .tmp3q, .tmp4q, .src1b, ._ },
                        .{ ._, ._, .mov, .leai(.tmp2q, .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp4q, ._, ._ },
                        .{ .@"1:", ._, .add, .tmp1p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_size), .tmp3q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } },
                        .{ .unsigned_int = .byte },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leasia(.none, .@"8", .tmp0, .sub_src0_size), ._, ._ },
                        .{ ._, ._, .not, .tmp0p, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsia(.dst0, .@"8", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memia(.src0q, .tmp1, .add_size), ._, ._ },
                        .{ ._, ._mp, .j, .@"1f", ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp4q, .memia(.src0q, .tmp1, .add_size), ._, ._ },
                        .{ ._, ._rd, .sh, .tmp3q, .tmp4q, .src1b, ._ },
                        .{ ._, ._, .mov, .leai(.tmp2q, .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp4q, ._, ._ },
                        .{ .@"1:", ._, .add, .tmp1p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_size), .tmp3q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } },
                        .{ .unsigned_int = .byte },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leasia(.none, .@"8", .tmp0, .sub_src0_size), ._, ._ },
                        .{ ._, ._, .not, .tmp0p, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsia(.dst0, .@"8", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memia(.src0q, .tmp1, .add_size), ._, ._ },
                        .{ ._, ._mp, .j, .@"1f", ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp4q, .memia(.src0q, .tmp1, .add_size), ._, ._ },
                        .{ ._, ._rd, .sh, .tmp3q, .tmp4q, .src1b, ._ },
                        .{ ._, ._, .mov, .leai(.tmp2q, .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp4q, ._, ._ },
                        .{ .@"1:", ._, .add, .tmp1p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._r, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_size), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } },
                        .{ .unsigned_int = .byte },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leasia(.none, .@"8", .tmp0, .sub_src0_size), ._, ._ },
                        .{ ._, ._, .not, .tmp0p, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsia(.dst0, .@"8", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memia(.src0q, .tmp1, .add_size), ._, ._ },
                        .{ ._, ._mp, .j, .@"1f", ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp4q, .memia(.src0q, .tmp1, .add_size), ._, ._ },
                        .{ ._, ._rd, .sh, .tmp3q, .tmp4q, .src1b, ._ },
                        .{ ._, ._, .mov, .leai(.tmp2q, .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp4q, ._, ._ },
                        .{ .@"1:", ._, .add, .tmp1p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._r, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_size), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } },
                        .{ .unsigned_int = .word },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cx }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1w, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leasia(.none, .@"8", .tmp0, .sub_src0_size), ._, ._ },
                        .{ ._, ._, .not, .tmp0p, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsia(.dst0, .@"8", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memia(.src0q, .tmp1, .add_size), ._, ._ },
                        .{ ._, ._mp, .j, .@"1f", ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp4q, .memia(.src0q, .tmp1, .add_size), ._, ._ },
                        .{ ._, ._rd, .sh, .tmp3q, .tmp4q, .src1b, ._ },
                        .{ ._, ._, .mov, .leai(.tmp2q, .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp4q, ._, ._ },
                        .{ .@"1:", ._, .add, .tmp1p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_size), .tmp3q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } },
                        .{ .unsigned_int = .word },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cx }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1w, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leasia(.none, .@"8", .tmp0, .sub_src0_size), ._, ._ },
                        .{ ._, ._, .not, .tmp0p, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsia(.dst0, .@"8", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memia(.src0q, .tmp1, .add_size), ._, ._ },
                        .{ ._, ._mp, .j, .@"1f", ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp4q, .memia(.src0q, .tmp1, .add_size), ._, ._ },
                        .{ ._, ._rd, .sh, .tmp3q, .tmp4q, .src1b, ._ },
                        .{ ._, ._, .mov, .leai(.tmp2q, .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp4q, ._, ._ },
                        .{ .@"1:", ._, .add, .tmp1p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_size), .tmp3q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } },
                        .{ .unsigned_int = .word },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cx }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1w, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leasia(.none, .@"8", .tmp0, .sub_src0_size), ._, ._ },
                        .{ ._, ._, .not, .tmp0p, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsia(.dst0, .@"8", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memia(.src0q, .tmp1, .add_size), ._, ._ },
                        .{ ._, ._mp, .j, .@"1f", ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp4q, .memia(.src0q, .tmp1, .add_size), ._, ._ },
                        .{ ._, ._rd, .sh, .tmp3q, .tmp4q, .src1b, ._ },
                        .{ ._, ._, .mov, .leai(.tmp2q, .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp4q, ._, ._ },
                        .{ .@"1:", ._, .add, .tmp1p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._r, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_size), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } },
                        .{ .unsigned_int = .word },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cx }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1w, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leasia(.none, .@"8", .tmp0, .sub_src0_size), ._, ._ },
                        .{ ._, ._, .not, .tmp0p, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsia(.dst0, .@"8", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memia(.src0q, .tmp1, .add_size), ._, ._ },
                        .{ ._, ._mp, .j, .@"1f", ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp4q, .memia(.src0q, .tmp1, .add_size), ._, ._ },
                        .{ ._, ._rd, .sh, .tmp3q, .tmp4q, .src1b, ._ },
                        .{ ._, ._, .mov, .leai(.tmp2q, .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp4q, ._, ._ },
                        .{ .@"1:", ._, .add, .tmp1p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._r, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_size), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f} {f} {f}", .{
                        @tagName(air_tag),
                        cg.typeOf(bin_op.lhs).fmt(pt),
                        cg.typeOf(bin_op.rhs).fmt(pt),
                        ops[0].tracking(cg),
                        ops[1].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
            },
            .shl, .shl_exact => |air_tag| {
                const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                var res: [1]Temp = undefined;
                cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{
                    .src_constraints = .{ .{ .signed_int = .byte }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .imm8, .none } },
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                        .{ .src = .{ .mut_mem, .{ .to_reg = .cl }, .none } },
                        .{ .src = .{ .to_mut_gpr, .{ .to_reg = .cl }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._l, .sa, .dst0b, .src1b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .imm8, .none } },
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                        .{ .src = .{ .mut_mem, .{ .to_reg = .cl }, .none } },
                        .{ .src = .{ .to_mut_gpr, .{ .to_reg = .cl }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._l, .sh, .dst0b, .src1b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .exact_unsigned_int = 4 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .imm8, .none } },
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                        .{ .src = .{ .mut_mem, .{ .to_reg = .cl }, .none } },
                        .{ .src = .{ .to_mut_gpr, .{ .to_reg = .cl }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._l, .sa, .dst0w, .src1b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .exact_unsigned_int = 4 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .imm8, .none } },
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                        .{ .src = .{ .mut_mem, .{ .to_reg = .cl }, .none } },
                        .{ .src = .{ .to_mut_gpr, .{ .to_reg = .cl }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._l, .sh, .dst0w, .src1b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .dword }, .{ .exact_unsigned_int = 5 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .imm8, .none } },
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._l, .sa, .dst0d, .src1b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .exact_unsigned_int = 5 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .imm8, .none } },
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._l, .sh, .dst0d, .src1b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi2, null, null, null },
                    .src_constraints = .{ .{ .int = .dword }, .{ .exact_unsigned_int = 5 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .to_gpr, .none } },
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._lx, .sh, .dst0d, .src0d, .src1d, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .dword }, .{ .exact_unsigned_int = 5 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .{ .to_reg = .cl }, .none } },
                        .{ .src = .{ .to_mut_gpr, .{ .to_reg = .cl }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._l, .sa, .dst0d, .src1b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .exact_unsigned_int = 5 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .{ .to_reg = .cl }, .none } },
                        .{ .src = .{ .to_mut_gpr, .{ .to_reg = .cl }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._l, .sh, .dst0d, .src1b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .{ .exact_unsigned_int = 6 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .imm8, .none } },
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._l, .sa, .dst0q, .src1b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .exact_unsigned_int = 6 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .imm8, .none } },
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._l, .sh, .dst0q, .src1b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, null, null },
                    .src_constraints = .{ .{ .int = .qword }, .{ .exact_unsigned_int = 6 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .to_gpr, .none } },
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._lx, .sh, .dst0q, .src0q, .src1q, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .{ .exact_unsigned_int = 6 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .{ .to_reg = .cl }, .none } },
                        .{ .src = .{ .to_mut_gpr, .{ .to_reg = .cl }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._l, .sa, .dst0q, .src1b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .exact_unsigned_int = 6 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .{ .to_reg = .cl }, .none } },
                        .{ .src = .{ .to_mut_gpr, .{ .to_reg = .cl }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._l, .sh, .dst0q, .src1b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .remainder_int = .{ .of = .qword, .is = .qword } },
                        .{ .unsigned_int = .byte },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._mp, .j, .@"1f", ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp4q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp4q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp4q, ._, ._ },
                        .{ .@"1:", ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_int = .{ .of = .qword, .is = .qword } },
                        .{ .unsigned_int = .byte },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._mp, .j, .@"1f", ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp4q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp4q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp4q, ._, ._ },
                        .{ .@"1:", ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .remainder_int = .{ .of = .qword, .is = .qword } },
                        .{ .unsigned_int = .word },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cx }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1w, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._mp, .j, .@"1f", ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp4q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp4q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp4q, ._, ._ },
                        .{ .@"1:", ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_int = .{ .of = .qword, .is = .qword } },
                        .{ .unsigned_int = .word },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cx }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src1w, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._mp, .j, .@"1f", ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp4q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp4q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp4q, ._, ._ },
                        .{ .@"1:", ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f} {f} {f}", .{
                        @tagName(air_tag),
                        cg.typeOf(bin_op.lhs).fmt(pt),
                        cg.typeOf(bin_op.rhs).fmt(pt),
                        ops[0].tracking(cg),
                        ops[1].tracking(cg),
                    }),
                    else => |e| return e,
                };
                switch (air_tag) {
                    else => unreachable,
                    .shl => res[0].wrapInt(cg) catch |err| switch (err) {
                        error.SelectFailed => return cg.fail("failed to select {s} wrap {f} {f}", .{
                            @tagName(air_tag),
                            cg.typeOf(bin_op.lhs).fmt(pt),
                            res[0].tracking(cg),
                        }),
                        else => |e| return e,
                    },
                    .shl_exact => {},
                }
                try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
            },
            .shl_sat => |air_tag| {
                const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                const lhs_ty = cg.typeOf(bin_op.lhs);
                var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                var res: [1]Temp = undefined;
                switch (ops[1].tracking(cg).short) {
                    .immediate => |rhs_imm| res[0] = try cg.tempInit(
                        .i32,
                        .{ .immediate = if (rhs_imm < cg.intInfo(lhs_ty).?.bits)
                            rhs_imm
                        else
                            @bitCast(@as(i64, -1)) },
                    ),
                    else => cg.select(&res, &.{.i32}, ops[1..2], comptime &.{ .{
                        .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_gpr, .none, .none } },
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .movzx, .dst0d, .src0b, ._, ._ },
                        } },
                    }, .{
                        .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_gpr, .none, .none } },
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .movzx, .dst0d, .src0w, ._, ._ },
                        } },
                    }, .{
                        .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mut_mem, .none, .none } },
                            .{ .src = .{ .to_mut_gpr, .none, .none } },
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{} },
                    }, .{
                        .required_features = .{ .@"64bit", .cmov, null, null },
                        .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_gpr, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .si(1 << 16), ._, ._ },
                            .{ ._, ._, .cmp, .src0q, .tmp0q, ._, ._ },
                            .{ ._, ._nb, .cmov, .dst0d, .tmp0d, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .@"64bit", null, null, null },
                        .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_gpr, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .cmp, .src0q, .si(1 << 16), ._, ._ },
                            .{ ._, ._, .cmc, ._, ._, ._, ._ },
                            .{ ._, ._, .sbb, .tmp0d, .tmp0d, ._, ._ },
                            .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .@"64bit", .cmov, null, null },
                        .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .reg = .ecx }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
                            .{ ._, ._, .mov, .dst0d, .si(1 << 16), ._, ._ },
                            .{ .@"0:", ._, .cmp, .memi(.src0q, .tmp0), .si(0), ._, ._ },
                            .{ ._, ._ne, .j, .@"0f", ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                            .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._, .mov, .tmp0q, .mem(.src0q), ._, ._ },
                            .{ ._, ._, .cmp, .tmp0q, .dst0q, ._, ._ },
                            .{ ._, ._na, .cmov, .dst0d, .tmp0d, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .@"64bit", null, null, null },
                        .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .reg = .ecx }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
                            .{ ._, ._, .mov, .dst0d, .si(1 << 16), ._, ._ },
                            .{ .@"0:", ._, .cmp, .memi(.src0q, .tmp0), .si(0), ._, ._ },
                            .{ ._, ._ne, .j, .@"0f", ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                            .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._, .mov, .tmp0q, .mem(.src0q), ._, ._ },
                            .{ ._, ._, .cmp, .dst0q, .tmp0q, ._, ._ },
                            .{ ._, ._, .sbb, .dst0d, .dst0d, ._, ._ },
                            .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ },
                        } },
                    } }) catch |err| switch (err) {
                        error.SelectFailed => return cg.fail("failed to select {s} {f} {f}", .{
                            @tagName(air_tag),
                            cg.typeOf(bin_op.rhs).fmt(pt),
                            ops[1].tracking(cg),
                        }),
                        else => |e| return e,
                    },
                }
                if (ops[1].index != res[0].index) try ops[1].die(cg);
                ops[1] = res[0];
                cg.select(&res, &.{lhs_ty}, &ops, comptime &.{ .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .byte }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = -1 }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0b, .ui(7), ._, ._ },
                        .{ ._, ._, .xor, .tmp0b, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .@"test", .dst0b, .src0b, ._, ._ },
                        .{ ._, ._nz, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .byte }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = -1 }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .@"test", .dst0b, .src0b, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0b, .ui(7), ._, ._ },
                        .{ ._, ._, .xor, .dst0b, .sa(.src0, .add_smax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 8 }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = 1 }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0b, .ui(7), ._, ._ },
                        .{ ._, ._, .xor, .tmp0b, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .add, .dst0b, .src0b, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_signed_int = 8 }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = 1 }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0b, .src0b, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0b, .ui(7), ._, ._ },
                        .{ ._, ._, .xor, .dst0b, .sa(.src0, .add_smin), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .byte }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0b, .ui(7), ._, ._ },
                        .{ ._, ._, .lea, .tmp1d, .leaad(.src0, .add_smax_shr_src1, 1), ._, ._ },
                        .{ ._, ._l, .sa, .dst0b, .src1b, ._, ._ },
                        .{ ._, ._, .xor, .tmp0b, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1b, .ua(.src0, .add_umax_shr_src1), ._, ._ },
                        .{ ._, ._a, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .byte }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0d, .leaad(.src0, .add_smax_shr_src1, 1), ._, ._ },
                        .{ ._, ._, .cmp, .tmp0b, .ua(.src0, .add_umax_shr_src1), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0b, .ui(7), ._, ._ },
                        .{ ._, ._, .xor, .dst0b, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._mp, .j, .@"0f", ._, ._, ._ },
                        .{ .@"1:", ._l, .sa, .dst0b, .src1b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .byte }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .{ .to_reg = .ecx }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src1d, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .@"test", .src0b, .src0b, ._, ._ },
                        .{ .@"0:", ._, .mov, .dst0d, .src0d, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0b, .ui(7), ._, ._ },
                        .{ ._, ._, .xor, .dst0b, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._mp, .j, .@"0f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .dst0d, .src0d, ._, ._ },
                        .{ ._, ._l, .sa, .dst0b, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0b, .uia(8, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0b, .uia(8, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0b, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .tmp0b, .src0b, ._, ._ },
                        .{ ._, ._ne, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = -1 }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .@"test", .dst0b, .src0b, ._, ._ },
                        .{ ._, ._nz, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = -1 }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .@"test", .dst0b, .src0b, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .ua(.src0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .exact_unsigned_int = 8 }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = 1 }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .add, .dst0b, .src0b, ._, ._ },
                        .{ ._, ._c, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_unsigned_int = 8 }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = 1 }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0b, .src0b, ._, ._ },
                        .{ ._, ._nc, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .ua(.src0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0d, .src0d, ._, ._ },
                        .{ ._, ._l, .sh, .dst0b, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .src0b, .ua(.src0, .add_umax_shr_src1), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._a, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0d, .src0d, ._, ._ },
                        .{ ._, ._l, .sh, .dst0b, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .src0b, .ua(.src0, .add_umax_shr_src1), ._, ._ },
                        .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .ua(.src0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .to_reg = .ecx }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0d, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .cmp, .src1d, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .@"test", .src0b, .src0b, ._, ._ },
                        .{ ._, ._z, .cmov, .dst0d, .src0d, ._, ._ },
                        .{ ._, ._mp, .j, .@"0f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0b, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .src0d, ._, ._ },
                        .{ ._, ._l, .sh, .tmp1b, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .src0b, .tmp0b, ._, ._ },
                        .{ ._, ._na, .cmov, .dst0d, .tmp1d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .to_reg = .ecx }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0d, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .cmp, .src1d, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .@"test", .src0b, .src0b, ._, ._ },
                        .{ ._, ._nz, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                        .{ ._, ._mp, .j, .@"0f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0b, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .src0d, ._, ._ },
                        .{ ._, ._l, .sh, .tmp1b, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .src0b, .tmp0b, ._, ._ },
                        .{ ._, ._a, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .tmp1d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .fast_imm16, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = -1 }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .tmp0w, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .@"test", .dst0w, .src0w, ._, ._ },
                        .{ ._, ._nz, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = -1 }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .@"test", .dst0w, .src0w, ._, ._ },
                        .{ ._, ._nz, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = -1 }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .@"test", .dst0w, .src0w, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .dst0w, .sa(.src0, .add_smax), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = -1 }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .@"test", .dst0w, .src0w, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .fast_imm16, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 16 }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = 1 }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .tmp0w, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .add, .dst0w, .src0w, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 16 }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = 1 }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .add, .dst0w, .src0w, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 16 }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = 1 }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0w, .src0w, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .dst0w, .sa(.src0, .add_smin), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_signed_int = 16 }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = 1 }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0w, .src0w, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smin), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .fast_imm16, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ },
                        .{ ._, ._, .lea, .tmp1d, .leaad(.src0, .add_smax_shr_src1, 1), ._, ._ },
                        .{ ._, ._l, .sa, .dst0d, .src1b, ._, ._ },
                        .{ ._, ._, .xor, .tmp0w, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1w, .ua(.src0, .add_umax_shr_src1), ._, ._ },
                        .{ ._, ._a, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ },
                        .{ ._, ._, .lea, .tmp1d, .leaad(.src0, .add_smax_shr_src1, 1), ._, ._ },
                        .{ ._, ._l, .sa, .dst0d, .src1b, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1w, .ua(.src0, .add_umax_shr_src1), ._, ._ },
                        .{ ._, ._a, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0d, .leaad(.src0, .add_smax_shr_src1, 1), ._, ._ },
                        .{ ._, ._, .cmp, .tmp0w, .ua(.src0, .add_umax_shr_src1), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .dst0w, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._mp, .j, .@"0f", ._, ._, ._ },
                        .{ .@"1:", ._l, .sa, .dst0d, .src1b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0d, .leaad(.src0, .add_smax_shr_src1, 1), ._, ._ },
                        .{ ._, ._, .cmp, .tmp0w, .ua(.src0, .add_umax_shr_src1), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._mp, .j, .@"0f", ._, ._, ._ },
                        .{ .@"1:", ._l, .sa, .dst0d, .src1b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .{ .to_reg = .ecx }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src1d, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .@"test", .src0w, .src0w, ._, ._ },
                        .{ .@"0:", ._, .mov, .dst0d, .src0d, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .dst0w, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._mp, .j, .@"0f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .dst0d, .src0d, ._, ._ },
                        .{ ._, ._l, .sa, .dst0d, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0d, .uia(32, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0d, .uia(32, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .tmp0w, .src0w, ._, ._ },
                        .{ ._, ._ne, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .{ .to_reg = .ecx }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src1d, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .@"test", .src0w, .src0w, ._, ._ },
                        .{ .@"0:", ._, .mov, .dst0d, .src0d, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ },
                        .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._mp, .j, .@"0f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .dst0d, .src0d, ._, ._ },
                        .{ ._, ._l, .sa, .dst0d, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0d, .uia(32, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0d, .uia(32, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .tmp0w, .src0w, ._, ._ },
                        .{ ._, ._ne, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = -1 }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .@"test", .dst0w, .src0w, ._, ._ },
                        .{ ._, ._nz, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = -1 }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .@"test", .dst0w, .src0w, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .ua(.src0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .exact_unsigned_int = 16 }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = 1 }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .add, .dst0w, .src0w, ._, ._ },
                        .{ ._, ._c, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_unsigned_int = 16 }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = 1 }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0w, .src0w, ._, ._ },
                        .{ ._, ._nc, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .ua(.src0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0d, .src0d, ._, ._ },
                        .{ ._, ._l, .sh, .dst0d, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .src0w, .ua(.src0, .add_umax_shr_src1), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._a, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0d, .src0d, ._, ._ },
                        .{ ._, ._l, .sh, .dst0d, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .src0w, .ua(.src0, .add_umax_shr_src1), ._, ._ },
                        .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .ua(.src0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .to_reg = .ecx }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0d, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .cmp, .src1d, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .@"test", .src0w, .src0w, ._, ._ },
                        .{ ._, ._z, .cmov, .dst0d, .src0d, ._, ._ },
                        .{ ._, ._mp, .j, .@"0f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0w, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .src0d, ._, ._ },
                        .{ ._, ._l, .sh, .tmp1d, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .src0w, .tmp0w, ._, ._ },
                        .{ ._, ._na, .cmov, .dst0d, .tmp1d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .to_reg = .ecx }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0d, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .cmp, .src1d, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .@"test", .src0w, .src0w, ._, ._ },
                        .{ ._, ._nz, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                        .{ ._, ._mp, .j, .@"0f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0w, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .src0d, ._, ._ },
                        .{ ._, ._l, .sh, .tmp1d, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .src0w, .tmp0w, ._, ._ },
                        .{ ._, ._a, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .tmp1d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .dword }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = -1 }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .@"test", .dst0d, .src0d, ._, ._ },
                        .{ ._, ._nz, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .dword }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = -1 }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .@"test", .dst0d, .src0d, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 32 }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = 1 }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .add, .dst0d, .src0d, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_signed_int = 32 }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = 1 }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0d, .src0d, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smin), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .dword }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0d, .ui(31), ._, ._ },
                        .{ ._, ._, .lea, .tmp1d, .leaad(.src0, .add_smax_shr_src1, 1), ._, ._ },
                        .{ ._, ._l, .sa, .dst0d, .src1b, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1d, .ua(.src0, .add_umax_shr_src1), ._, ._ },
                        .{ ._, ._a, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .dword }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0d, .leaad(.src0, .add_smax_shr_src1, 1), ._, ._ },
                        .{ ._, ._, .cmp, .tmp0d, .ua(.src0, .add_umax_shr_src1), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._mp, .j, .@"0f", ._, ._, ._ },
                        .{ .@"1:", ._l, .sa, .dst0d, .src1b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .dword }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .{ .to_reg = .ecx }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src1d, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .@"test", .src0d, .src0d, ._, ._ },
                        .{ .@"0:", ._, .mov, .dst0d, .src0d, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0d, .ui(31), ._, ._ },
                        .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smax), ._, ._ },
                        .{ ._, ._mp, .j, .@"0f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .dst0d, .src0d, ._, ._ },
                        .{ ._, ._l, .sa, .dst0d, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0d, .uia(32, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0d, .uia(32, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._ne, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = -1 }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .@"test", .dst0d, .src0d, ._, ._ },
                        .{ ._, ._nz, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = -1 }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .@"test", .dst0d, .src0d, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .ua(.src0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = 1 }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .add, .dst0d, .src0d, ._, ._ },
                        .{ ._, ._c, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = 1 }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0d, .src0d, ._, ._ },
                        .{ ._, ._nc, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .ua(.src0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0d, .src0d, ._, ._ },
                        .{ ._, ._l, .sh, .dst0d, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .src0d, .ua(.src0, .add_umax_shr_src1), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._a, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0d, .src0d, ._, ._ },
                        .{ ._, ._l, .sh, .dst0d, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .src0d, .ua(.src0, .add_umax_shr_src1), ._, ._ },
                        .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .ua(.src0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .to_reg = .ecx }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0d, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .cmp, .src1d, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .@"test", .src0d, .src0d, ._, ._ },
                        .{ ._, ._z, .cmov, .dst0d, .src0d, ._, ._ },
                        .{ ._, ._mp, .j, .@"0f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .src0d, ._, ._ },
                        .{ ._, ._l, .sh, .tmp1d, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .src0d, .tmp0d, ._, ._ },
                        .{ ._, ._na, .cmov, .dst0d, .tmp1d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .to_reg = .ecx }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0d, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .cmp, .src1d, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .@"test", .src0d, .src0d, ._, ._ },
                        .{ ._, ._nz, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                        .{ ._, ._mp, .j, .@"0f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .src0d, ._, ._ },
                        .{ ._, ._l, .sh, .tmp1d, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .src0d, .tmp0d, ._, ._ },
                        .{ ._, ._a, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .tmp1d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = -1 }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .xor, .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._, .@"test", .dst0q, .src0q, ._, ._ },
                        .{ ._, ._nz, .cmov, .dst0q, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = -1 }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .@"test", .dst0q, .src0q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .xor, .dst0q, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 64 }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = 1 }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .xor, .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .dst0q, .src0q, ._, ._ },
                        .{ ._, ._o, .cmov, .dst0q, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 64 }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = 1 }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0q, .src0q, ._, ._ },
                        .{ ._, ._no, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_smin), ._, ._ },
                        .{ ._, ._, .xor, .dst0q, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .leaad(.src0, .add_smax_shr_src1, 1), ._, ._ },
                        .{ ._, ._l, .sa, .dst0q, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .xor, .tmp0q, .tmp2q, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_umax_shr_src1), ._, ._ },
                        .{ ._, ._, .cmp, .tmp1q, .tmp2q, ._, ._ },
                        .{ ._, ._a, .cmov, .dst0q, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .qword }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0q, .leaad(.src0, .add_smax_shr_src1, 1), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_umax_shr_src1), ._, ._ },
                        .{ ._, ._, .cmp, .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .xor, .dst0q, .tmp1q, ._, ._ },
                        .{ ._, ._mp, .j, .@"0f", ._, ._, ._ },
                        .{ .@"1:", ._l, .sa, .dst0q, .src1b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .qword }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .{ .to_reg = .ecx }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src1d, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .@"test", .src0q, .src0q, ._, ._ },
                        .{ .@"0:", ._, .mov, .dst0q, .src0q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .xor, .dst0q, .tmp0q, ._, ._ },
                        .{ ._, ._mp, .j, .@"0f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .dst0q, .src0q, ._, ._ },
                        .{ ._, ._l, .sa, .dst0q, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .tmp0q, .src0q, ._, ._ },
                        .{ ._, ._ne, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = -1 }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .@"test", .dst0q, .src0q, ._, ._ },
                        .{ ._, ._nz, .cmov, .dst0q, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = -1 }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .@"test", .dst0q, .src0q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0q, .ua(.src0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = 1 }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .add, .dst0q, .src0q, ._, ._ },
                        .{ ._, ._c, .cmov, .dst0q, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .imm = 1 }, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0q, .src0q, ._, ._ },
                        .{ ._, ._nc, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0q, .ua(.src0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0q, .src0q, ._, ._ },
                        .{ ._, ._l, .sh, .dst0q, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax_shr_src1), ._, ._ },
                        .{ ._, ._, .cmp, .src0q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._a, .cmov, .dst0q, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0q, .src0q, ._, ._ },
                        .{ ._, ._l, .sh, .dst0q, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax_shr_src1), ._, ._ },
                        .{ ._, ._, .cmp, .src0q, .tmp0q, ._, ._ },
                        .{ ._, ._na, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0q, .ua(.src0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .to_reg = .ecx }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .cmp, .src1d, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .@"test", .src0q, .src0q, ._, ._ },
                        .{ ._, ._z, .cmov, .dst0q, .src0q, ._, ._ },
                        .{ ._, ._mp, .j, .@"0f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp0q, .dst0q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0q, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .src0q, ._, ._ },
                        .{ ._, ._l, .sh, .tmp1q, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .src0q, .tmp0q, ._, ._ },
                        .{ ._, ._na, .cmov, .dst0q, .tmp1q, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .exact_signed_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .{ .to_reg = .ecx }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .cmp, .src1d, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .@"test", .src0q, .src0q, ._, ._ },
                        .{ ._, ._nz, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .xor, .dst0q, .dst0q, ._, ._ },
                        .{ ._, ._mp, .j, .@"0f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp0q, .dst0q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0q, .src1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .src0q, ._, ._ },
                        .{ ._, ._l, .sh, .tmp1q, .src1b, ._, ._ },
                        .{ ._, ._, .cmp, .src0q, .tmp0q, ._, ._ },
                        .{ ._, ._a, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0q, .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 128 } },
                        .{ .exact_signed_int = 32 },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .reg = .rax } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src1d, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .cmp, .memi(.src0q, .tmp0), .si(0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp0d, .src1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp5q, .tmp4q, .src1b, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .leasi(.tmp2q, .@"8", .tmp6), ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._, .sub, .tmp6d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp6q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp6q, ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp4q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._r, .sa, .tmp7q, .ui(63), ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp0q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .not, .tmp0q, ._, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .src1d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 128 } },
                        .{ .exact_signed_int = 32 },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .reg = .rax } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src1d, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .cmp, .memi(.src0q, .tmp0), .si(0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp0d, .src1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp5q, .tmp4q, .src1b, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .leasi(.tmp2q, .@"8", .tmp6), ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._c, .de, .tmp6d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._s, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp6q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp6q, ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp4q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._r, .sa, .tmp7q, .ui(63), ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp0q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .not, .tmp0q, ._, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .src1d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 128 } },
                        .{ .exact_signed_int = 32 },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .reg = .rax } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src1d, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .cmp, .memi(.src0q, .tmp0), .si(0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp0d, .src1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .@"or", .tmp4q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .sub, .tmp5d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp5q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .@"test", .tmp4q, .tmp4q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp0q, .si(-1), ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .src1d, .sa(.dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 128 } },
                        .{ .exact_signed_int = 32 },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .reg = .rax } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src1d, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .cmp, .memi(.src0q, .tmp0), .si(0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp0d, .src1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .@"or", .tmp4q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._s, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp5q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .@"test", .tmp4q, .tmp4q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp0q, .si(-1), ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .src1d, .sa(.dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 64 } },
                        .{ .exact_signed_int = 32 },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .reg = .rax } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src1d, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .cmp, .memi(.src0q, .tmp0), .si(0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp0d, .src1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp5q, .tmp4q, .src1b, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .leasi(.tmp2q, .@"8", .tmp6), ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._, .sub, .tmp6d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp6q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp6q, ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp4q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.dst0q, .add_src0_size, -16), ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._, .xor, .tmp3q, .tmp1q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp0q, .memad(.src0q, .add_size, -16), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .not, .tmp0q, ._, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .src1d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp1q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 64 } },
                        .{ .exact_signed_int = 32 },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .reg = .rax } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src1d, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .cmp, .memi(.src0q, .tmp0), .si(0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp0d, .src1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp5q, .tmp4q, .src1b, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .leasi(.tmp2q, .@"8", .tmp6), ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._c, .de, .tmp6d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._s, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp6q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp6q, ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp4q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.dst0q, .add_src0_size, -16), ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._, .xor, .tmp3q, .tmp1q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp0q, .memad(.src0q, .add_size, -16), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .not, .tmp0q, ._, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .src1d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp1q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .{ .exact_signed_int = 32 },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .reg = .rax } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src1d, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .cmp, .memi(.src0q, .tmp0), .si(0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp0d, .src1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .@"or", .tmp4q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .sub, .tmp5d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp5q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .@"test", .tmp4q, .tmp4q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp0q, .si(-1), ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .src1d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } },
                        .{ .exact_signed_int = 32 },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .reg = .rax } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src1d, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .cmp, .memi(.src0q, .tmp0), .si(0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp0d, .src1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .@"or", .tmp4q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._s, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp5q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .@"test", .tmp4q, .tmp4q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp0q, .si(-1), ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .src1d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } },
                        .{ .exact_signed_int = 32 },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .reg = .rax } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src1d, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .cmp, .memi(.src0q, .tmp0), .si(0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp0d, .src1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp5q, .tmp4q, .src1b, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .leasi(.tmp2q, .@"8", .tmp6), ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._, .sub, .tmp6d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp6q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp6q, ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp4q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.dst0q, .add_src0_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp1q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp1q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._, .xor, .tmp0q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp0q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp0q, .memad(.src0q, .add_size, -16), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .not, .tmp0q, ._, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .src1d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -16), .tmp1q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } },
                        .{ .exact_signed_int = 32 },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .reg = .rax } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src1d, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .cmp, .memi(.src0q, .tmp0), .si(0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp0d, .src1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp5q, .tmp4q, .src1b, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .leasi(.tmp2q, .@"8", .tmp6), ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._c, .de, .tmp6d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._s, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp6q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp6q, ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp4q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.dst0q, .add_src0_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp1q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp1q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._, .xor, .tmp0q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp0q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp0q, .memad(.src0q, .add_size, -16), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .not, .tmp0q, ._, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .src1d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -16), .tmp1q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi, .slow_incdec, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .{ .exact_signed_int = 32 },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .reg = .rax } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src1d, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .cmp, .memi(.src0q, .tmp0), .si(0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp0d, .src1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .@"or", .tmp4q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .sub, .tmp5d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp5q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.dst0q, .add_src0_size, -16), ._, ._ },
                        .{ ._, ._, .andn, .tmp5q, .tmp1q, .tmp3q, ._ },
                        .{ ._, ._, .@"and", .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp0q, .si(-1), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.dst0, .add_umax), ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .src1d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -16), .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .{ .exact_signed_int = 32 },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .reg = .rax } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src1d, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .cmp, .memi(.src0q, .tmp0), .si(0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp0d, .src1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .@"or", .tmp4q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._s, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp5q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.dst0q, .add_src0_size, -16), ._, ._ },
                        .{ ._, ._, .andn, .tmp5q, .tmp1q, .tmp3q, ._ },
                        .{ ._, ._, .@"and", .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp0q, .si(-1), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.dst0, .add_umax), ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .src1d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -16), .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .{ .exact_signed_int = 32 },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .reg = .rax } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src1d, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .cmp, .memi(.src0q, .tmp0), .si(0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp0d, .src1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .@"or", .tmp4q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .sub, .tmp5d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp5q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -16), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1q, .tmp5q, ._, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp1q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp0q, .si(-1), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.dst0, .add_umax), ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .src1d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -16), .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } },
                        .{ .exact_signed_int = 32 },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .reg = .rax } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src1d, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .cmp, .memi(.src0q, .tmp0), .si(0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp0d, .src1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .@"or", .tmp4q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._s, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp5q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -16), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1q, .tmp5q, ._, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp1q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp0q, .si(-1), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.dst0, .add_umax), ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .src1d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -16), .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } },
                        .{ .exact_signed_int = 32 },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .reg = .rax } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src1d, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .cmp, .memi(.src0q, .tmp0), .si(0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp0d, .src1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp5q, .tmp4q, .src1b, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .leasi(.tmp2q, .@"8", .tmp6), ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._, .sub, .tmp6d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp6q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp6q, ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp4q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp1q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp1q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._, .xor, .tmp0q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp0q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp0q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .not, .tmp0q, ._, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .src1d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } },
                        .{ .exact_signed_int = 32 },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .reg = .rax } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src1d, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .cmp, .memi(.src0q, .tmp0), .si(0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp0d, .src1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp5q, .tmp4q, .src1b, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .leasi(.tmp2q, .@"8", .tmp6), ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._c, .de, .tmp6d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._s, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp6q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp6q, ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp4q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp1q, ._, ._ },
                        .{ ._, ._l, .sa, .tmp1q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .xor, .tmp7q, .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp7q, ._, ._ },
                        .{ ._, ._, .xor, .tmp0q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp0q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp0q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .not, .tmp0q, ._, ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .src1d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi, .slow_incdec, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .{ .exact_signed_int = 32 },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .reg = .rax } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src1d, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .cmp, .memi(.src0q, .tmp0), .si(0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp0d, .src1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .@"or", .tmp4q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .sub, .tmp5d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp5q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .andn, .tmp5q, .tmp1q, .tmp3q, ._ },
                        .{ ._, ._, .@"and", .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp0q, .si(-1), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.dst0, .add_umax), ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .src1d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .{ .exact_signed_int = 32 },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .reg = .rax } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src1d, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .cmp, .memi(.src0q, .tmp0), .si(0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp0d, .src1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .@"or", .tmp4q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._s, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp5q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .andn, .tmp5q, .tmp1q, .tmp3q, ._ },
                        .{ ._, ._, .@"and", .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp0q, .si(-1), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.dst0, .add_umax), ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .src1d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .{ .exact_signed_int = 32 },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .reg = .rax } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src1d, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .cmp, .memi(.src0q, .tmp0), .si(0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp0d, .src1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .@"or", .tmp4q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._, .sub, .tmp5d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._nae, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp5q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1q, .tmp5q, ._, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp1q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp0q, .si(-1), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.dst0, .add_umax), ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .src1d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } },
                        .{ .exact_signed_int = 32 },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .{ .to_reg = .cl }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .reg = .rax } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src1d, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._na, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .cmp, .memi(.src0q, .tmp0), .si(0), ._, ._ },
                        .{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp0d, .src1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ },
                        .{ ._, ._, .@"test", .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .@"or", .tmp4q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ },
                        .{ ._, ._c, .de, .tmp5d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._s, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memsid(.dst0, .@"8", .tmp0, 8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .memsi(.src0q, .@"8", .tmp1), ._, ._ },
                        .{ ._, ._ld, .sh, .tmp3q, .tmp5q, .src1b, ._ },
                        .{ ._, ._, .mov, .leasi(.tmp2q, .@"8", .tmp1), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .tmp5q, ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ .@"1:", ._l, .sh, .tmp3q, .src1b, ._, ._ },
                        .{ .@"0:", ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -8), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1q, .tmp5q, ._, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp1q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ .@"2:", ._, .mov, .tmp0q, .si(-1), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.dst0, .add_umax), ._, ._ },
                        .{ .@"3:", ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .src1d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f} {f}", .{
                        @tagName(air_tag),
                        lhs_ty.fmt(pt),
                        ops[0].tracking(cg),
                        ops[1].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
            },
            .not => |air_tag| {
                const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                var res: [1]Temp = undefined;
                cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{
                    .src_constraints = .{ .{ .bool_vec = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .not, .dst0b, ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_or_exact_int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .not, .dst0b, ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .dst0b, .sa(.src0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .bool_vec = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .not, .dst0w, ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_or_exact_int = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .not, .dst0w, ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .dst0w, .sa(.src0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .bool_vec = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .not, .dst0d, ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_or_exact_int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .not, .dst0d, ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .bool_vec = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .not, .dst0q, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .signed_or_exact_int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .not, .dst0q, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .xor, .dst0q, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .mmx, null, null, null },
                    .src_constraints = .{ .{ .bool_vec = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_mmx, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .mmx }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_d, .cmpeq, .dst0q, .dst0q, ._, ._ },
                        .{ ._, .p_, .xor, .dst0q, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .mmx, null, null, null },
                    .src_constraints = .{ .{ .signed_or_exact_int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_mmx, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .mmx }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_d, .cmpeq, .dst0q, .dst0q, ._, ._ },
                        .{ ._, .p_, .xor, .dst0q, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .mmx, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_mmx, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .src0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_, .xor, .dst0q, .lea(.tmp0q), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .bool_vec = .xword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_q, .cmpeq, .dst0x, .dst0x, .dst0x, ._ },
                        .{ ._, .vp_, .xor, .dst0x, .dst0x, .src0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .signed_or_exact_int = .xword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_q, .cmpeq, .dst0x, .dst0x, .dst0x, ._ },
                        .{ ._, .vp_, .xor, .dst0x, .dst0x, .src0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .src0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_, .xor, .dst0x, .src0x, .lea(.tmp0x), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .bool_vec = .xword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_d, .cmpeq, .dst0x, .dst0x, ._, ._ },
                        .{ ._, .p_, .xor, .dst0x, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .signed_or_exact_int = .xword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_d, .cmpeq, .dst0x, .dst0x, ._, ._ },
                        .{ ._, .p_, .xor, .dst0x, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .src0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_, .xor, .dst0x, .lea(.tmp0x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .bool_vec = .xword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .src0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._ps, .xor, .dst0x, .lea(.tmp0x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .int = .xword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .src0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._ps, .xor, .dst0x, .lea(.tmp0x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .bool_vec = .yword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_q, .cmpeq, .dst0y, .dst0y, .dst0y, ._ },
                        .{ ._, .vp_, .xor, .dst0y, .dst0y, .src0y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .signed_or_exact_int = .yword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_q, .cmpeq, .dst0y, .dst0y, .dst0y, ._ },
                        .{ ._, .vp_, .xor, .dst0y, .dst0y, .src0y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .yword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .src0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_, .xor, .dst0y, .src0y, .lea(.tmp0y), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .bool_vec = .yword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_pd, .cmp, .dst0y, .dst0y, .dst0y, .vp(.true) },
                        .{ ._, .v_pd, .xor, .dst0y, .dst0y, .src0y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .signed_or_exact_int = .yword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_pd, .cmp, .dst0y, .dst0y, .dst0y, .vp(.true) },
                        .{ ._, .v_pd, .xor, .dst0y, .dst0y, .src0y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .yword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .src0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_pd, .xor, .dst0y, .src0y, .lea(.tmp0y), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .remainder_bool_vec = .{ .of = .yword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_size), ._, ._ },
                        .{ ._, .vp_q, .cmpeq, .tmp1y, .tmp1y, .tmp1y, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp2y, .tmp1y, .memiad(.src0y, .tmp0, .add_size, -16), ._ },
                        .{ ._, .v_dqu, .mov, .memiad(.dst0y, .tmp0, .add_size, -16), .tmp2y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp2x, .tmp1x, .memad(.src0x, .add_size, -16), ._ },
                        .{ ._, .v_dqa, .mov, .memad(.dst0x, .add_size, -16), .tmp2x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .signed_or_exact_remainder_int = .{ .of = .yword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_size), ._, ._ },
                        .{ ._, .vp_q, .cmpeq, .tmp1y, .tmp1y, .tmp1y, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp2y, .tmp1y, .memiad(.src0y, .tmp0, .add_size, -16), ._ },
                        .{ ._, .v_dqu, .mov, .memiad(.dst0y, .tmp0, .add_size, -16), .tmp2y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp2x, .tmp1x, .memad(.src0x, .add_size, -16), ._ },
                        .{ ._, .v_dqa, .mov, .memad(.dst0x, .add_size, -16), .tmp2x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .remainder_bool_vec = .{ .of = .yword, .is = .yword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ ._, .vp_q, .cmpeq, .tmp1y, .tmp1y, .tmp1y, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp2y, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._ },
                        .{ ._, .v_dqu, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp2y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .signed_or_exact_remainder_int = .{ .of = .yword, .is = .yword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ ._, .vp_q, .cmpeq, .tmp1y, .tmp1y, .tmp1y, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp2y, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._ },
                        .{ ._, .v_dqu, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp2y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .remainder_bool_vec = .{ .of = .yword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_size), ._, ._ },
                        .{ ._, .v_pd, .cmp, .tmp1y, .tmp1y, .tmp1y, .vp(.true) },
                        .{ .@"0:", .v_pd, .xor, .tmp2y, .tmp1y, .memiad(.src0y, .tmp0, .add_size, -16), ._ },
                        .{ ._, .v_pd, .movu, .memiad(.dst0y, .tmp0, .add_size, -16), .tmp2y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ .@"0:", .v_pd, .xor, .tmp2x, .tmp1x, .memad(.src0x, .add_size, -16), ._ },
                        .{ ._, .v_pd, .mova, .memad(.dst0x, .add_size, -16), .tmp2x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .signed_or_exact_remainder_int = .{ .of = .yword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_size), ._, ._ },
                        .{ ._, .v_pd, .cmp, .tmp1y, .tmp1y, .tmp1y, .vp(.true) },
                        .{ .@"0:", .v_pd, .xor, .tmp2y, .tmp1y, .memiad(.src0y, .tmp0, .add_size, -16), ._ },
                        .{ ._, .v_pd, .movu, .memiad(.dst0y, .tmp0, .add_size, -16), .tmp2y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ .@"0:", .v_pd, .xor, .tmp2x, .tmp1x, .memad(.src0x, .add_size, -16), ._ },
                        .{ ._, .v_pd, .mova, .memad(.dst0x, .add_size, -16), .tmp2x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .remainder_bool_vec = .{ .of = .yword, .is = .yword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ ._, .v_pd, .cmp, .tmp1y, .tmp1y, .tmp1y, .vp(.true) },
                        .{ .@"0:", .v_pd, .xor, .tmp2y, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._ },
                        .{ ._, .v_pd, .movu, .memia(.dst0y, .tmp0, .add_size), .tmp2y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .signed_or_exact_remainder_int = .{ .of = .yword, .is = .yword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ ._, .v_pd, .cmp, .tmp1y, .tmp1y, .tmp1y, .vp(.true) },
                        .{ .@"0:", .v_pd, .xor, .tmp2y, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._ },
                        .{ ._, .v_pd, .movu, .memia(.dst0y, .tmp0, .add_size), .tmp2y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .remainder_bool_vec = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ ._, .vp_q, .cmpeq, .tmp1x, .tmp1x, .tmp1x, ._ },
                        .{ .@"0:", .v_, .xor, .tmp2x, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp2x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .signed_or_exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ ._, .vp_q, .cmpeq, .tmp1x, .tmp1x, .tmp1x, ._ },
                        .{ .@"0:", .v_, .xor, .tmp2x, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp2x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .remainder_bool_vec = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ ._, .p_d, .cmpeq, .tmp1x, .tmp1x, ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .tmp1x, ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp2x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .signed_or_exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ ._, .p_d, .cmpeq, .tmp1x, .tmp1x, ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .tmp1x, ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp2x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .remainder_bool_vec = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .not, .memia(.dst0q, .tmp0, .add_size), ._, ._, ._ },
                        .{ ._, ._, .not, .memiad(.dst0q, .tmp0, .add_size, 8), ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .signed_or_exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .not, .memia(.dst0q, .tmp0, .add_size), ._, ._, ._ },
                        .{ ._, ._, .not, .memiad(.dst0q, .tmp0, .add_size, 8), ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .remainder_bool_vec = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .not, .tmp1q, ._, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .signed_or_exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .not, .tmp1q, ._, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .exact_remainder_int = .{ .of = .xword, .is = 32 } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .not, .memiad(.dst0q, .tmp0, .add_size, -16), ._, ._, ._ },
                        .{ ._, ._, .not, .memiad(.dst0q, .tmp0, .add_size, -16 + 8), ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .not, .memad(.dst0d, .add_size, -16), ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .exact_remainder_int = .{ .of = .xword, .is = 32 } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memiad(.src0q, .tmp0, .add_size, -16), ._, ._ },
                        .{ ._, ._, .not, .tmp1q, ._, ._, ._ },
                        .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_size, -16), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .memad(.src0d, .add_size, -16), ._, ._ },
                        .{ ._, ._, .not, .tmp0d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0d, .add_size, -16), .tmp0d, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0d, .add_size, -16 + 4), .si(0), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16 + 8), .si(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .exact_remainder_int = .{ .of = .qword, .is = 64 } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .not, .memiad(.dst0q, .tmp0, .add_size, -16), ._, ._, ._ },
                        .{ ._, ._, .not, .memiad(.dst0q, .tmp0, .add_size, -16 + 8), ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .not, .memad(.dst0q, .add_size, -16), ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .exact_remainder_int = .{ .of = .qword, .is = 64 } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(8, .src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memiad(.src0q, .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .not, .tmp1q, ._, ._, ._ },
                        .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_size, -8), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .exact_remainder_int = .{ .of = .dword, .is = 32 } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(8, .src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .not, .memiad(.dst0q, .tmp0, .add_size, -8), ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .not, .memad(.dst0d, .add_size, -8), ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .exact_remainder_int = .{ .of = .dword, .is = 32 } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(8, .src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memiad(.src0q, .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .not, .tmp1q, ._, ._, ._ },
                        .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_size, -8), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .memad(.src0d, .add_size, -8), ._, ._ },
                        .{ ._, ._, .not, .tmp0d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0d, .add_size, -8), .tmp0d, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0d, .add_size, -8 + 4), .si(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .not, .memiad(.dst0q, .tmp0, .add_size, -16), ._, ._, ._ },
                        .{ ._, ._, .not, .memiad(.dst0q, .tmp0, .add_size, -16 + 8), ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .xor, .memad(.dst0d, .add_size, -16), .sa(.src0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memiad(.src0q, .tmp0, .add_size, -16), ._, ._ },
                        .{ ._, ._, .not, .tmp1q, ._, ._, ._ },
                        .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_size, -16), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .memad(.src0d, .add_size, -16), ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0d, .add_size, -16), .tmp0d, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0d, .add_size, -16 + 4), .si(0), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16 + 8), .si(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .remainder_int = .{ .of = .qword, .is = .dword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(8, .src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .not, .memiad(.dst0q, .tmp0, .add_size, -8), ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .xor, .memad(.dst0d, .add_size, -8), .sa(.src0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .remainder_int = .{ .of = .qword, .is = .dword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(8, .src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memiad(.src0q, .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .not, .tmp1q, ._, ._, ._ },
                        .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_size, -8), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .memad(.src0d, .add_size, -8), ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0d, .add_size, -8), .tmp0d, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0d, .add_size, -8 + 4), .si(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .not, .memiad(.dst0q, .tmp0, .add_size, -16), ._, ._, ._ },
                        .{ ._, ._, .not, .memiad(.dst0q, .tmp0, .add_size, -16 + 8), ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .xor, .memad(.dst0q, .add_size, -16), .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memiad(.src0q, .tmp0, .add_size, -16), ._, ._ },
                        .{ ._, ._, .not, .tmp1q, ._, ._, ._ },
                        .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_size, -16), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .xor, .tmp0q, .memad(.src0q, .add_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(8, .src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .not, .memiad(.dst0q, .tmp0, .add_size, -8), ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .xor, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(8, .src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memiad(.src0q, .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .not, .tmp1q, ._, ._, ._ },
                        .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_size, -8), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .xor, .tmp0q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .mmx, null, null, null },
                    .src_constraints = .{ .{ .signed_int_or_full_vec = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_mmx, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .mmx }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_d, .cmpeq, .dst0q, .dst0q, ._, ._ },
                        .{ ._, .p_, .xor, .dst0q, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .mmx, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int_vec = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_mmx, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .src0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_, .xor, .dst0q, .lea(.tmp0q), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .signed_int_or_full_vec = .xword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_q, .cmpeq, .dst0x, .dst0x, .dst0x, ._ },
                        .{ ._, .vp_, .xor, .dst0x, .dst0x, .src0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int_vec = .xword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .src0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_, .xor, .dst0x, .src0x, .lea(.tmp0x), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .signed_int_or_full_vec = .xword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_d, .cmpeq, .dst0x, .dst0x, ._, ._ },
                        .{ ._, .p_, .xor, .dst0x, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int_vec = .xword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .src0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_, .xor, .dst0x, .lea(.tmp0x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int_vec = .xword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .src0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._ps, .xor, .dst0x, .lea(.tmp0x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .signed_int_or_full_vec = .yword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_q, .cmpeq, .dst0y, .dst0y, .dst0y, ._ },
                        .{ ._, .vp_, .xor, .dst0y, .dst0y, .src0y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int_vec = .yword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .src0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_, .xor, .dst0y, .src0y, .lea(.tmp0y), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .signed_int_or_full_vec = .yword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_pd, .cmp, .dst0y, .dst0y, .dst0y, .vp(.true) },
                        .{ ._, .v_pd, .xor, .dst0y, .dst0y, .src0y, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int_vec = .yword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .src0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_pd, .xor, .dst0y, .src0y, .lea(.tmp0y), ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .remainder_bool_vec = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .not, .tmp1q, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp1q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .remainder_bool_vec = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .not, .tmp1q, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp1q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .any_signed_int_or_full_vec, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size_up_8), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .not, .tmp1q, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp1q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .signed_or_exact_remainder_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .not, .tmp1q, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp1q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .src0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size_up_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp3), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp2q, .leai(.tmp1q, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp2q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .remainder_bool_vec = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .not, .tmp1d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp1d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .any_signed_int_or_full_vec, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size_up_4), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .not, .tmp1d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp1d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_or_exact_remainder_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .not, .tmp1d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp1d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .src0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size_up_8), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp3), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .leai(.tmp1d, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp2d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f}", .{
                        @tagName(air_tag),
                        ty_op.ty.toType().fmt(pt),
                        ops[0].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{ty_op.operand}, &ops, cg);
            },
            .bitcast => try cg.airBitCast(inst),
            .block => {
                const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
                const block = cg.air.extraData(Air.Block, ty_pl.payload);
                if (!cg.mod.strip) try cg.asmPseudo(.pseudo_dbg_enter_block_none);
                try cg.lowerBlock(inst, @ptrCast(cg.air.extra.items[block.end..][0..block.data.body_len]));
                if (!cg.mod.strip) try cg.asmPseudo(.pseudo_dbg_leave_block_none);
            },
            .loop => {
                const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
                const block = cg.air.extraData(Air.Block, ty_pl.payload);
                try cg.loops.putNoClobber(cg.gpa, inst, .{
                    .state = try cg.saveState(),
                    .target = @intCast(cg.mir_instructions.len),
                });
                defer assert(cg.loops.remove(inst));
                try cg.genBodyBlock(@ptrCast(cg.air.extra.items[block.end..][0..block.data.body_len]));
            },
            .repeat => {
                const repeat = air_datas[@intFromEnum(inst)].repeat;
                const loop = cg.loops.get(repeat.loop_inst).?;
                try cg.restoreState(loop.state, &.{}, .{
                    .emit_instructions = true,
                    .update_tracking = false,
                    .resurrect = false,
                    .close_scope = false,
                });
                _ = try cg.asmJmpReloc(loop.target);
            },
            .br => try cg.airBr(inst),
            .trap => try cg.asmOpOnly(.{ ._2, .ud }),
            .breakpoint => try cg.asmOpOnly(.{ ._3, .int }),
            .ret_addr => {
                var slot = try cg.tempInit(.usize, .{ .load_frame = .{
                    .index = .ret_addr,
                } });
                while (try slot.toRegClass(true, .general_purpose, cg)) {}
                try slot.finish(inst, &.{}, &.{}, cg);
            },
            .frame_addr => {
                const slot = try cg.tempInit(.usize, .{ .lea_frame = .{
                    .index = .base_ptr,
                } });
                try slot.finish(inst, &.{}, &.{}, cg);
            },
            .call => try cg.airCall(inst, .auto, .{ .safety = true }),
            .call_always_tail => try cg.airCall(inst, .always_tail, .{ .safety = true }),
            .call_never_tail => try cg.airCall(inst, .never_tail, .{ .safety = true }),
            .call_never_inline => try cg.airCall(inst, .never_inline, .{ .safety = true }),
            .clz => |air_tag| {
                const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                var res: [1]Temp = undefined;
                cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 1 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0b, .si(1), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_signed_int = 1 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._c, .in, .dst0b, ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_unsigned_int = 1 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .dst0b, .si(1), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .lzcnt, null, null, null },
                    .src_constraints = .{ .{ .unsigned_or_exact_int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .dst0d, .src0b, ._, ._ },
                        .{ ._, ._, .lzcnt, .dst0d, .dst0d, ._, ._ },
                        .{ ._, ._, .sub, .dst0b, .sia(32, .src0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .lzcnt, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .dst0d, .src0b, ._, ._ },
                        .{ ._, ._, .@"and", .dst0d, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .lzcnt, .dst0d, .dst0d, ._, ._ },
                        .{ ._, ._, .sub, .dst0b, .sia(32, .src0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .false_deps_lzcnt_tzcnt, .lzcnt, null, null },
                    .src_constraints = .{ .{ .exact_int = 16 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lzcnt, .dst0w, .src0w, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .lzcnt, null, null, null },
                    .src_constraints = .{ .{ .exact_int = 16 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lzcnt, .dst0w, .src0w, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .lzcnt, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .@"and", .src0w, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .lzcnt, .dst0w, .src0w, ._, ._ },
                        .{ ._, ._, .sub, .dst0b, .sia(16, .src0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .false_deps_lzcnt_tzcnt, .lzcnt, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lzcnt, .dst0w, .src0w, ._, ._ },
                        .{ ._, ._, .sub, .dst0b, .sia(16, .src0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .lzcnt, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lzcnt, .dst0w, .src0w, ._, ._ },
                        .{ ._, ._, .sub, .dst0b, .sia(16, .src0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .false_deps_lzcnt_tzcnt, .lzcnt, null, null },
                    .src_constraints = .{ .{ .exact_int = 32 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lzcnt, .dst0d, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .lzcnt, null, null, null },
                    .src_constraints = .{ .{ .exact_int = 32 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lzcnt, .dst0d, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .lzcnt, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .@"and", .src0d, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .lzcnt, .dst0d, .src0d, ._, ._ },
                        .{ ._, ._, .sub, .dst0b, .sia(32, .src0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .false_deps_lzcnt_tzcnt, .lzcnt, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lzcnt, .dst0d, .src0d, ._, ._ },
                        .{ ._, ._, .sub, .dst0b, .sia(32, .src0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .lzcnt, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lzcnt, .dst0d, .src0d, ._, ._ },
                        .{ ._, ._, .sub, .dst0b, .sia(32, .src0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null },
                    .src_constraints = .{ .{ .exact_int = 64 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lzcnt, .dst0q, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .lzcnt, null, null },
                    .src_constraints = .{ .{ .exact_int = 64 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lzcnt, .dst0q, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .lzcnt, null, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .@"and", .dst0q, .src0q, ._, ._ },
                        .{ ._, ._, .lzcnt, .dst0q, .dst0q, ._, ._ },
                        .{ ._, ._, .sub, .dst0b, .sia(64, .src0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lzcnt, .dst0q, .src0q, ._, ._ },
                        .{ ._, ._, .sub, .dst0b, .sia(64, .src0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .lzcnt, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lzcnt, .dst0q, .src0q, ._, ._ },
                        .{ ._, ._, .sub, .dst0b, .sia(64, .src0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null },
                    .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .dst0d, .src0b, ._, ._ },
                        .{ ._, ._r, .bs, .dst0d, .dst0d, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_2_bit_size), ._, ._ },
                        .{ ._, ._z, .cmov, .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .xor, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null },
                    .src_constraints = .{ .{ .signed_po2_int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .dst0d, .src0b, ._, ._ },
                        .{ ._, ._, .@"and", .dst0d, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._r, .bs, .dst0d, .dst0d, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_2_bit_size), ._, ._ },
                        .{ ._, ._z, .cmov, .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .xor, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null },
                    .src_constraints = .{ .{ .signed_int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ },
                        .{ ._, ._, .@"and", .tmp0d, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._r, .bs, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .si(-1), ._, ._ },
                        .{ ._, ._z, .cmov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .sub, .dst0b, .tmp0b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ },
                        .{ ._, ._r, .bs, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .si(-1), ._, ._ },
                        .{ ._, ._z, .cmov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .sub, .dst0b, .tmp0b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null },
                    .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .dst0d, .src0b, ._, ._ },
                        .{ ._, ._r, .bs, .dst0d, .dst0d, ._, ._ },
                        .{ ._, ._nz, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_2_bit_size), ._, ._ },
                        .{ .@"0:", ._, .xor, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null },
                    .src_constraints = .{ .{ .signed_po2_int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .dst0d, .src0b, ._, ._ },
                        .{ ._, ._, .@"and", .dst0d, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._r, .bs, .dst0d, .dst0d, ._, ._ },
                        .{ ._, ._nz, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_2_bit_size), ._, ._ },
                        .{ .@"0:", ._, .xor, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ },
                        .{ ._, ._, .@"and", .tmp0d, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._r, .bs, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .mov, .dst0b, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ ._, ._, .sbb, .dst0b, .tmp0b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ },
                        .{ ._, ._r, .bs, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .mov, .dst0b, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ ._, ._, .sbb, .dst0b, .tmp0b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .sia(-1, .src0, .add_2_bit_size), ._, ._ },
                        .{ ._, ._r, .bs, .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .xor, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_po2_int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ },
                        .{ ._, ._, .@"and", .tmp0d, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .sia(-1, .src0, .add_2_bit_size), ._, ._ },
                        .{ ._, ._r, .bs, .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .xor, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .dst0d, .src0b, ._, ._ },
                        .{ ._, ._, .@"and", .dst0d, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .si(-1), ._, ._ },
                        .{ ._, ._r, .bs, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .sub, .dst0b, .tmp0b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .dst0d, .src0b, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .si(-1), ._, ._ },
                        .{ ._, ._r, .bs, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .sub, .dst0b, .tmp0b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null },
                    .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._r, .bs, .src0w, .src0w, ._, ._ },
                        .{ ._, ._, .mov, .dst0w, .sia(-1, .src0, .add_2_bit_size), ._, ._ },
                        .{ ._, ._nz, .cmov, .dst0w, .src0w, ._, ._ },
                        .{ ._, ._, .xor, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .@"and", .src0w, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._r, .bs, .src0w, .src0w, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .si(-1), ._, ._ },
                        .{ ._, ._z, .cmov, .src0d, .dst0d, ._, ._ },
                        .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .sub, .dst0b, .src0b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._r, .bs, .src0w, .src0w, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .si(-1), ._, ._ },
                        .{ ._, ._z, .cmov, .src0d, .dst0d, ._, ._ },
                        .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .sub, .dst0b, .src0b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null },
                    .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._r, .bs, .dst0w, .src0w, ._, ._ },
                        .{ ._, ._nz, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_2_bit_size), ._, ._ },
                        .{ .@"0:", ._, .xor, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .@"and", .src0w, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._r, .bs, .src0w, .src0w, ._, ._ },
                        .{ ._, ._, .mov, .dst0b, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ ._, ._, .sbb, .dst0b, .src0b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._r, .bs, .src0w, .src0w, ._, ._ },
                        .{ ._, ._, .mov, .dst0b, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ ._, ._, .sbb, .dst0b, .src0b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0w, .sia(-1, .src0, .add_2_bit_size), ._, ._ },
                        .{ ._, ._r, .bs, .dst0w, .src0w, ._, ._ },
                        .{ ._, ._, .xor, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .@"and", .src0w, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .si(-1), ._, ._ },
                        .{ ._, ._r, .bs, .tmp0w, .src0w, ._, ._ },
                        .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .sub, .dst0b, .tmp0b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .si(-1), ._, ._ },
                        .{ ._, ._r, .bs, .tmp0w, .src0w, ._, ._ },
                        .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .sub, .dst0b, .tmp0b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null },
                    .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._r, .bs, .src0d, .src0d, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .sia(-1, .src0, .add_2_bit_size), ._, ._ },
                        .{ ._, ._nz, .cmov, .dst0d, .src0d, ._, ._ },
                        .{ ._, ._, .xor, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null },
                    .src_constraints = .{ .{ .signed_int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .@"and", .src0d, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._r, .bs, .src0d, .src0d, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .si(-1), ._, ._ },
                        .{ ._, ._z, .cmov, .src0d, .dst0d, ._, ._ },
                        .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .sub, .dst0b, .src0b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._r, .bs, .src0d, .src0d, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .si(-1), ._, ._ },
                        .{ ._, ._z, .cmov, .src0d, .dst0d, ._, ._ },
                        .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .sub, .dst0b, .src0b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null },
                    .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._r, .bs, .dst0d, .src0d, ._, ._ },
                        .{ ._, ._nz, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_2_bit_size), ._, ._ },
                        .{ .@"0:", ._, .xor, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .@"and", .src0d, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._r, .bs, .src0d, .src0d, ._, ._ },
                        .{ ._, ._, .mov, .dst0b, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ ._, ._, .sbb, .dst0b, .src0b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._r, .bs, .src0d, .src0d, ._, ._ },
                        .{ ._, ._, .mov, .dst0b, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ ._, ._, .sbb, .dst0b, .src0b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0d, .sia(-1, .src0, .add_2_bit_size), ._, ._ },
                        .{ ._, ._r, .bs, .dst0d, .src0d, ._, ._ },
                        .{ ._, ._, .xor, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .@"and", .src0d, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .si(-1), ._, ._ },
                        .{ ._, ._r, .bs, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .sub, .dst0b, .tmp0b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .si(-1), ._, ._ },
                        .{ ._, ._r, .bs, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .sub, .dst0b, .tmp0b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, .bsf_bsr_0_clobbers_result, null },
                    .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._r, .bs, .src0q, .src0q, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .sia(-1, .src0, .add_2_bit_size), ._, ._ },
                        .{ ._, ._nz, .cmov, .dst0d, .src0d, ._, ._ },
                        .{ ._, ._, .xor, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, .bsf_bsr_0_clobbers_result, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0q, .src0q, ._, ._ },
                        .{ ._, ._r, .bs, .tmp0q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .si(-1), ._, ._ },
                        .{ ._, ._z, .cmov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .sub, .dst0b, .tmp0b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, .bsf_bsr_0_clobbers_result, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._r, .bs, .src0q, .src0q, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .si(-1), ._, ._ },
                        .{ ._, ._z, .cmov, .src0d, .dst0d, ._, ._ },
                        .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .sub, .dst0b, .src0b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bsf_bsr_0_clobbers_result, null, null },
                    .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._r, .bs, .dst0q, .src0q, ._, ._ },
                        .{ ._, ._nz, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_2_bit_size), ._, ._ },
                        .{ .@"0:", ._, .xor, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bsf_bsr_0_clobbers_result, null, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0q, .src0q, ._, ._ },
                        .{ ._, ._r, .bs, .tmp0q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .dst0b, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ ._, ._, .sbb, .dst0b, .tmp0b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bsf_bsr_0_clobbers_result, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._r, .bs, .src0q, .src0q, ._, ._ },
                        .{ ._, ._, .mov, .dst0b, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ ._, ._, .sbb, .dst0b, .src0b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0d, .sia(-1, .src0, .add_2_bit_size), ._, ._ },
                        .{ ._, ._r, .bs, .dst0q, .src0q, ._, ._ },
                        .{ ._, ._, .xor, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .@"and", .dst0q, .src0q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .si(-1), ._, ._ },
                        .{ ._, ._r, .bs, .tmp0q, .dst0q, ._, ._ },
                        .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .sub, .dst0b, .tmp0b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .si(-1), ._, ._ },
                        .{ ._, ._r, .bs, .tmp0q, .src0q, ._, ._ },
                        .{ ._, ._, .mov, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .sub, .dst0b, .tmp0b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null },
                    .src_constraints = .{ .{ .unsigned_or_exact_remainder_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .xor, .dst0d, .dst0d, ._, ._ },
                        .{ ._, ._, .lzcnt, .dst0q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._nc, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .neg, .tmp0d, ._, ._, ._ },
                        .{ ._, ._, .lea, .dst0d, .leasiad(.dst0, .@"8", .tmp0, .add_src0_bit_size, -64), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .lzcnt, null, null },
                    .src_constraints = .{ .{ .unsigned_or_exact_remainder_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .lzcnt, .dst0q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._nc, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .neg, .tmp0d, ._, ._, ._ },
                        .{ ._, ._, .lea, .dst0d, .leasiad(.dst0, .@"8", .tmp0, .add_src0_bit_size, -64), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bsf_bsr_0_clobbers_result, null, null },
                    .src_constraints = .{ .{ .unsigned_or_exact_remainder_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .xor, .dst0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .bs, .dst0q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .si(-1), ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .lea, .dst0d, .leasiad(.dst0, .@"8", .tmp0, .sub_src0_bit_size, 1), ._, ._ },
                        .{ ._, ._, .neg, .dst0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .unsigned_or_exact_remainder_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .dst0d, .si(-1), ._, ._ },
                        .{ ._, ._r, .bs, .dst0q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .lea, .dst0d, .leasiad(.dst0, .@"8", .tmp0, .sub_src0_bit_size, 1), ._, ._ },
                        .{ ._, ._, .neg, .dst0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null },
                    .src_constraints = .{ .{ .unsigned_or_exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .xor, .dst0d, .dst0d, ._, ._ },
                        .{ ._, ._, .lzcnt, .dst0q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._nc, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .neg, .tmp0d, ._, ._, ._ },
                        .{ ._, ._, .lea, .dst0d, .leasiad(.dst0, .@"8", .tmp0, .add_src0_bit_size, -64), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .lzcnt, null, null },
                    .src_constraints = .{ .{ .unsigned_or_exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .lzcnt, .dst0q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._nc, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .neg, .tmp0d, ._, ._, ._ },
                        .{ ._, ._, .lea, .dst0d, .leasiad(.dst0, .@"8", .tmp0, .add_src0_bit_size, -64), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bsf_bsr_0_clobbers_result, null, null },
                    .src_constraints = .{ .{ .unsigned_or_exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .xor, .dst0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .bs, .dst0q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .si(-1), ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .lea, .dst0d, .leasiad(.dst0, .@"8", .tmp0, .sub_src0_bit_size, 1), ._, ._ },
                        .{ ._, ._, .neg, .dst0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .unsigned_or_exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .dst0d, .si(-1), ._, ._ },
                        .{ ._, ._r, .bs, .dst0q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._nz, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .lea, .dst0d, .leasiad(.dst0, .@"8", .tmp0, .sub_src0_bit_size, 1), ._, ._ },
                        .{ ._, ._, .neg, .dst0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null },
                    .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ },
                        .{ .@"0:", ._, .xor, .dst0d, .dst0d, ._, ._ },
                        .{ ._, ._, .@"and", .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .lzcnt, .dst0q, .tmp1q, ._, ._ },
                        .{ ._, ._nc, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .si(-1), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .neg, .tmp0d, ._, ._, ._ },
                        .{ ._, ._, .lea, .dst0d, .leasiad(.dst0, .@"8", .tmp0, .add_src0_bit_size, -64), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .lzcnt, null, null },
                    .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ },
                        .{ .@"0:", ._, .@"and", .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .lzcnt, .dst0q, .tmp1q, ._, ._ },
                        .{ ._, ._nc, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .si(-1), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .neg, .tmp0d, ._, ._, ._ },
                        .{ ._, ._, .lea, .dst0d, .leasiad(.dst0, .@"8", .tmp0, .add_src0_bit_size, -64), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .dst0q, .ua(.src0, .add_umax), ._, ._ },
                        .{ .@"0:", ._, .@"and", .dst0q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._r, .bs, .dst0q, .dst0q, ._, ._ },
                        .{ ._, ._nz, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0q, .si(-1), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .lea, .dst0d, .leasiad(.dst0, .@"8", .tmp0, .sub_src0_bit_size, 1), ._, ._ },
                        .{ ._, ._, .neg, .dst0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null },
                    .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ },
                        .{ .@"0:", ._, .xor, .dst0d, .dst0d, ._, ._ },
                        .{ ._, ._, .@"and", .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .lzcnt, .dst0q, .tmp1q, ._, ._ },
                        .{ ._, ._nc, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .si(-1), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .neg, .tmp0d, ._, ._, ._ },
                        .{ ._, ._, .lea, .dst0d, .leasiad(.dst0, .@"8", .tmp0, .add_src0_bit_size, -64), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .lzcnt, null, null },
                    .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ },
                        .{ .@"0:", ._, .@"and", .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .lzcnt, .dst0q, .tmp1q, ._, ._ },
                        .{ ._, ._nc, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .si(-1), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .neg, .tmp0d, ._, ._, ._ },
                        .{ ._, ._, .lea, .dst0d, .leasiad(.dst0, .@"8", .tmp0, .add_src0_bit_size, -64), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .dst0q, .ua(.src0, .add_umax), ._, ._ },
                        .{ .@"0:", ._, .@"and", .dst0q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._r, .bs, .dst0q, .dst0q, ._, ._ },
                        .{ ._, ._nz, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0q, .si(-1), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .lea, .dst0d, .leasiad(.dst0, .@"8", .tmp0, .sub_src0_bit_size, 1), ._, ._ },
                        .{ ._, ._, .neg, .dst0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .lzcnt, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .scalar_int_is = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_len), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .lzcnt, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._, .sub, .tmp1b, .sia(32, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .lzcnt, null, null, null },
                    .src_constraints = .{ .{ .scalar_int_is = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_len), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .lzcnt, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._, .sub, .tmp1b, .sia(32, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .lzcnt, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .scalar_int_is = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0w, .@"2", .tmp0, .add_2_len), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .lzcnt, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._, .sub, .tmp1b, .sia(32, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .lzcnt, null, null, null },
                    .src_constraints = .{ .{ .scalar_int_is = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0w, .@"2", .tmp0, .add_2_len), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .lzcnt, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._, .sub, .tmp1b, .sia(32, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .lzcnt, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .scalar_int_is = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_4_len), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .lzcnt, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._, .sub, .tmp1b, .sia(32, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .lzcnt, null, null, null },
                    .src_constraints = .{ .{ .scalar_int_is = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_4_len), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .lzcnt, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._, .sub, .tmp1b, .sia(32, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .lzcnt, .slow_incdec, null },
                    .src_constraints = .{ .{ .scalar_int_is = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_8_len), ._, ._ },
                        .{ ._, ._, .lzcnt, .tmp1q, .tmp1q, ._, ._ },
                        .{ ._, ._, .sub, .tmp1b, .sia(64, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .lzcnt, null, null },
                    .src_constraints = .{ .{ .scalar_int_is = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_8_len), ._, ._ },
                        .{ ._, ._, .lzcnt, .tmp1q, .tmp1q, ._, ._ },
                        .{ ._, ._, .sub, .tmp1b, .sia(64, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, .slow_incdec, null },
                    .src_constraints = .{ .{ .scalar_int_is = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .si(-1), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_len), ._, ._ },
                        .{ ._, ._, .@"and", .tmp2d, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._r, .bs, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._z, .cmov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp3b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp3b, .tmp2b, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp3b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null },
                    .src_constraints = .{ .{ .scalar_int_is = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .si(-1), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_len), ._, ._ },
                        .{ ._, ._, .@"and", .tmp2d, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._r, .bs, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._z, .cmov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp3b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp3b, .tmp2b, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp3b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bsf_bsr_0_clobbers_result, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .scalar_int_is = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_len), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._r, .bs, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp2b, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ ._, ._, .sbb, .tmp2b, .tmp1b, ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp2b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null },
                    .src_constraints = .{ .{ .scalar_int_is = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_len), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._r, .bs, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp2b, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ ._, ._, .sbb, .tmp2b, .tmp1b, ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp2b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{ .{ .scalar_int_is = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_len), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .si(-1), ._, ._ },
                        .{ ._, ._r, .bs, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1b, .tmp2b, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .scalar_int_is = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_len), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .si(-1), ._, ._ },
                        .{ ._, ._r, .bs, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1b, .tmp2b, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, .slow_incdec, null },
                    .src_constraints = .{ .{ .scalar_int_is = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .si(-1), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp2d, .memsia(.src0w, .@"2", .tmp0, .add_2_len), ._, ._ },
                        .{ ._, ._, .@"and", .tmp2d, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._r, .bs, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._z, .cmov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp3b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp3b, .tmp2b, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp3b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null },
                    .src_constraints = .{ .{ .scalar_int_is = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .si(-1), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp2d, .memsia(.src0w, .@"2", .tmp0, .add_2_len), ._, ._ },
                        .{ ._, ._, .@"and", .tmp2d, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._r, .bs, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._z, .cmov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp3b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp3b, .tmp2b, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp3b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bsf_bsr_0_clobbers_result, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .scalar_int_is = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0w, .@"2", .tmp0, .add_2_len), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._r, .bs, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp2b, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ ._, ._, .sbb, .tmp2b, .tmp1b, ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp2b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null },
                    .src_constraints = .{ .{ .scalar_int_is = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0w, .@"2", .tmp0, .add_2_len), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._r, .bs, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp2b, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ ._, ._, .sbb, .tmp2b, .tmp1b, ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp2b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{ .{ .scalar_int_is = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0w, .@"2", .tmp0, .add_2_len), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .si(-1), ._, ._ },
                        .{ ._, ._r, .bs, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1b, .tmp2b, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .scalar_int_is = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0w, .@"2", .tmp0, .add_2_len), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .si(-1), ._, ._ },
                        .{ ._, ._r, .bs, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1b, .tmp2b, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, .slow_incdec, null },
                    .src_constraints = .{ .{ .scalar_int_is = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .si(-1), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2d, .memsia(.src0d, .@"4", .tmp0, .add_4_len), ._, ._ },
                        .{ ._, ._, .@"and", .tmp2d, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._r, .bs, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._z, .cmov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp3b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp3b, .tmp2b, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp3b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null },
                    .src_constraints = .{ .{ .scalar_int_is = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .si(-1), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2d, .memsia(.src0d, .@"4", .tmp0, .add_4_len), ._, ._ },
                        .{ ._, ._, .@"and", .tmp2d, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._r, .bs, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._z, .cmov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp3b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp3b, .tmp2b, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp3b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bsf_bsr_0_clobbers_result, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .scalar_int_is = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_4_len), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._r, .bs, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp2b, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ ._, ._, .sbb, .tmp2b, .tmp1b, ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp2b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null },
                    .src_constraints = .{ .{ .scalar_int_is = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_4_len), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._r, .bs, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp2b, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ ._, ._, .sbb, .tmp2b, .tmp1b, ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp2b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{ .{ .scalar_int_is = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_4_len), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .si(-1), ._, ._ },
                        .{ ._, ._r, .bs, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1b, .tmp2b, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .scalar_int_is = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_4_len), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1d, .sa(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .si(-1), ._, ._ },
                        .{ ._, ._r, .bs, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1b, .tmp2b, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, .bsf_bsr_0_clobbers_result, .slow_incdec },
                    .src_constraints = .{ .{ .scalar_int_is = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .si(-1), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .@"and", .tmp2q, .memsia(.src0q, .@"8", .tmp0, .add_8_len), ._, ._ },
                        .{ ._, ._r, .bs, .tmp2q, .tmp2q, ._, ._ },
                        .{ ._, ._z, .cmov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp3b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp3b, .tmp2b, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp3b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, .bsf_bsr_0_clobbers_result, null },
                    .src_constraints = .{ .{ .scalar_int_is = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .si(-1), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .@"and", .tmp2q, .memsia(.src0q, .@"8", .tmp0, .add_8_len), ._, ._ },
                        .{ ._, ._r, .bs, .tmp2q, .tmp2q, ._, ._ },
                        .{ ._, ._z, .cmov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp3b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp3b, .tmp2b, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp3b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bsf_bsr_0_clobbers_result, .slow_incdec, null },
                    .src_constraints = .{ .{ .scalar_int_is = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_8_len), ._, ._ },
                        .{ ._, ._r, .bs, .tmp1q, .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .tmp2b, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ ._, ._, .sbb, .tmp2b, .tmp1b, ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp2b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bsf_bsr_0_clobbers_result, null, null },
                    .src_constraints = .{ .{ .scalar_int_is = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_8_len), ._, ._ },
                        .{ ._, ._r, .bs, .tmp1q, .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .tmp2b, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._c, .st, ._, ._, ._, ._ },
                        .{ ._, ._, .sbb, .tmp2b, .tmp1b, ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp2b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{ .{ .scalar_int_is = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_8_len), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .si(-1), ._, ._ },
                        .{ ._, ._r, .bs, .tmp2q, .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .tmp1b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1b, .tmp2b, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .scalar_int_is = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_8_len), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .si(-1), ._, ._ },
                        .{ ._, ._r, .bs, .tmp2q, .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .tmp1b, .sia(-1, .src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1b, .tmp2b, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null },
                    .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int_is = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .mem(.src0), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2d, .sia(-16, .none, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_umax), ._, ._ },
                        .{ .@"1:", ._, .@"and", .tmp3q, .leai(.tmp1q, .tmp2), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .lzcnt, .tmp4q, .tmp3q, ._, ._ },
                        .{ ._, ._nc, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .si(-1), ._, ._ },
                        .{ ._, ._, .sub, .tmp2d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"1:", ._, .neg, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp3d, .leasiad(.tmp4, .@"8", .tmp2, .add_src0_bit_size, -64), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp3b, ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .leaa(.tmp1, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .lzcnt, null, null },
                    .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int_is = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .mem(.src0), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2d, .sia(-16, .none, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_umax), ._, ._ },
                        .{ .@"1:", ._, .@"and", .tmp3q, .leai(.tmp1q, .tmp2), ._, ._ },
                        .{ ._, ._, .lzcnt, .tmp4q, .tmp3q, ._, ._ },
                        .{ ._, ._nc, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .si(-1), ._, ._ },
                        .{ ._, ._, .sub, .tmp2d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"1:", ._, .neg, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp3d, .leasiad(.tmp4, .@"8", .tmp2, .add_src0_bit_size, -64), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp3b, ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .leaa(.tmp1, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int_is = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .mem(.src0), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2d, .sia(-16, .none, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_umax), ._, ._ },
                        .{ .@"1:", ._, .@"and", .tmp3q, .leai(.tmp1q, .tmp2), ._, ._ },
                        .{ ._, ._r, .bs, .tmp3q, .tmp3q, ._, ._ },
                        .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .si(-1), ._, ._ },
                        .{ ._, ._, .sub, .tmp2d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"1:", ._, .lea, .tmp3d, .leasiad(.tmp3, .@"8", .tmp2, .sub_src0_bit_size, 1), ._, ._ },
                        .{ ._, ._, .neg, .tmp3b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp3b, ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .leaa(.tmp1, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null },
                    .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int_is = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .mem(.src0), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2d, .sia(-8, .none, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_umax), ._, ._ },
                        .{ .@"1:", ._, .@"and", .tmp3q, .leai(.tmp1q, .tmp2), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .lzcnt, .tmp4q, .tmp3q, ._, ._ },
                        .{ ._, ._nc, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .si(-1), ._, ._ },
                        .{ ._, ._, .sub, .tmp2d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"1:", ._, .neg, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp3d, .leasiad(.tmp4, .@"8", .tmp2, .add_src0_bit_size, -64), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp3b, ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .leaa(.tmp1, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .lzcnt, null, null },
                    .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int_is = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .mem(.src0), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2d, .sia(-8, .none, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_umax), ._, ._ },
                        .{ .@"1:", ._, .@"and", .tmp3q, .leai(.tmp1q, .tmp2), ._, ._ },
                        .{ ._, ._, .lzcnt, .tmp4q, .tmp3q, ._, ._ },
                        .{ ._, ._nc, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .si(-1), ._, ._ },
                        .{ ._, ._, .sub, .tmp2d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"1:", ._, .neg, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp3d, .leasiad(.tmp4, .@"8", .tmp2, .add_src0_bit_size, -64), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp3b, ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .leaa(.tmp1, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int_is = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .mem(.src0), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2d, .sia(-8, .none, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_umax), ._, ._ },
                        .{ .@"1:", ._, .@"and", .tmp3q, .leai(.tmp1q, .tmp2), ._, ._ },
                        .{ ._, ._r, .bs, .tmp3q, .tmp3q, ._, ._ },
                        .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .si(-1), ._, ._ },
                        .{ ._, ._, .sub, .tmp2d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"1:", ._, .lea, .tmp3d, .leasiad(.tmp3, .@"8", .tmp2, .sub_src0_bit_size, 1), ._, ._ },
                        .{ ._, ._, .neg, .tmp3b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_len), .tmp3b, ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .leaa(.tmp1, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null },
                    .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int_is = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .mem(.src0), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2d, .sia(-16, .none, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_umax), ._, ._ },
                        .{ .@"1:", ._, .@"and", .tmp3q, .leai(.tmp1q, .tmp2), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .lzcnt, .tmp4q, .tmp3q, ._, ._ },
                        .{ ._, ._nc, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .si(-1), ._, ._ },
                        .{ ._, ._, .sub, .tmp2d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"1:", ._, .neg, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp3d, .leasiad(.tmp4, .@"8", .tmp2, .add_src0_bit_size, -64), ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_2_len), .tmp3w, ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .leaa(.tmp1, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .lzcnt, null, null },
                    .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int_is = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .mem(.src0), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2d, .sia(-16, .none, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_umax), ._, ._ },
                        .{ .@"1:", ._, .@"and", .tmp3q, .leai(.tmp1q, .tmp2), ._, ._ },
                        .{ ._, ._, .lzcnt, .tmp4q, .tmp3q, ._, ._ },
                        .{ ._, ._nc, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .si(-1), ._, ._ },
                        .{ ._, ._, .sub, .tmp2d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"1:", ._, .neg, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp3d, .leasiad(.tmp4, .@"8", .tmp2, .add_src0_bit_size, -64), ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_2_len), .tmp3w, ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .leaa(.tmp1, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int_is = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .mem(.src0), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2d, .sia(-16, .none, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_umax), ._, ._ },
                        .{ .@"1:", ._, .@"and", .tmp3q, .leai(.tmp1q, .tmp2), ._, ._ },
                        .{ ._, ._r, .bs, .tmp3q, .tmp3q, ._, ._ },
                        .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .si(-1), ._, ._ },
                        .{ ._, ._, .sub, .tmp2d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"1:", ._, .lea, .tmp3d, .leasiad(.tmp3, .@"8", .tmp2, .sub_src0_bit_size, 1), ._, ._ },
                        .{ ._, ._, .neg, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_2_len), .tmp3w, ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .leaa(.tmp1, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null },
                    .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int_is = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .mem(.src0), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2d, .sia(-8, .none, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_umax), ._, ._ },
                        .{ .@"1:", ._, .@"and", .tmp3q, .leai(.tmp1q, .tmp2), ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .lzcnt, .tmp4q, .tmp3q, ._, ._ },
                        .{ ._, ._nc, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .si(-1), ._, ._ },
                        .{ ._, ._, .sub, .tmp2d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"1:", ._, .neg, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp3d, .leasiad(.tmp4, .@"8", .tmp2, .add_src0_bit_size, -64), ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_2_len), .tmp3w, ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .leaa(.tmp1, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .lzcnt, null, null },
                    .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int_is = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .mem(.src0), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2d, .sia(-8, .none, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_umax), ._, ._ },
                        .{ .@"1:", ._, .@"and", .tmp3q, .leai(.tmp1q, .tmp2), ._, ._ },
                        .{ ._, ._, .lzcnt, .tmp4q, .tmp3q, ._, ._ },
                        .{ ._, ._nc, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .si(-1), ._, ._ },
                        .{ ._, ._, .sub, .tmp2d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"1:", ._, .neg, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp3d, .leasiad(.tmp4, .@"8", .tmp2, .add_src0_bit_size, -64), ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_2_len), .tmp3w, ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .leaa(.tmp1, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int_is = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .mem(.src0), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2d, .sia(-8, .none, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_umax), ._, ._ },
                        .{ .@"1:", ._, .@"and", .tmp3q, .leai(.tmp1q, .tmp2), ._, ._ },
                        .{ ._, ._r, .bs, .tmp3q, .tmp3q, ._, ._ },
                        .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .si(-1), ._, ._ },
                        .{ ._, ._, .sub, .tmp2d, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"1:", ._, .lea, .tmp3d, .leasiad(.tmp3, .@"8", .tmp2, .sub_src0_bit_size, 1), ._, ._ },
                        .{ ._, ._, .neg, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_2_len), .tmp3w, ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .leaa(.tmp1, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f}", .{
                        @tagName(air_tag),
                        cg.typeOf(ty_op.operand).fmt(pt),
                        ops[0].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{ty_op.operand}, &ops, cg);
            },
            .ctz => |air_tag| {
                const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                var res: [1]Temp = undefined;
                cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{ .{ .exact_signed_int = 1 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .add, .dst0b, .si(1), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_signed_int = 1 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._c, .in, .dst0b, ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_unsigned_int = 1 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .dst0b, .si(1), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi, null, null, null },
                    .src_constraints = .{ .{ .exact_int = 16 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                        .{ ._, ._, .tzcnt, .dst0w, .src0w, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi, .false_deps_lzcnt_tzcnt, null, null },
                    .src_constraints = .{ .{ .exact_int = 32 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                        .{ ._, ._, .tzcnt, .dst0d, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi, null, null, null },
                    .src_constraints = .{ .{ .exact_int = 32 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .tzcnt, .dst0d, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi, null, null, null },
                    .src_constraints = .{ .{ .int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .@"or", .src0d, .uia(1, .src0, .add_umax), ._, ._ },
                        .{ ._, ._, .tzcnt, .dst0d, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi, .false_deps_lzcnt_tzcnt, null },
                    .src_constraints = .{ .{ .exact_int = 64 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                        .{ ._, ._, .tzcnt, .dst0q, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi, null, null },
                    .src_constraints = .{ .{ .exact_int = 64 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .tzcnt, .dst0q, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi, null, null },
                    .src_constraints = .{ .{ .int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._s, .bt, .src0q, .ua(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .tzcnt, .dst0q, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null },
                    .src_constraints = .{ .{ .exact_int = 32 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .si(32), ._, ._ },
                        .{ ._, ._f, .bs, .dst0d, .src0d, ._, ._ },
                        .{ ._, ._z, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null },
                    .src_constraints = .{ .{ .exact_int = 32 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._f, .bs, .dst0d, .src0d, ._, ._ },
                        .{ ._, ._nz, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .si(32), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_int = 16 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0d, .si(16), ._, ._ },
                        .{ ._, ._f, .bs, .dst0w, .src0w, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_int = 32 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0d, .si(32), ._, ._ },
                        .{ ._, ._f, .bs, .dst0d, .src0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .@"or", .src0d, .uia(1, .src0, .add_umax), ._, ._ },
                        .{ ._, ._f, .bs, .dst0d, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, .bsf_bsr_0_clobbers_result, null },
                    .src_constraints = .{ .{ .exact_int = 64 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .si(64), ._, ._ },
                        .{ ._, ._f, .bs, .dst0q, .src0q, ._, ._ },
                        .{ ._, ._z, .cmov, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bsf_bsr_0_clobbers_result, null, null },
                    .src_constraints = .{ .{ .exact_int = 64 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._f, .bs, .dst0q, .src0q, ._, ._ },
                        .{ ._, ._nz, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .si(64), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_int = 64 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0d, .si(64), ._, ._ },
                        .{ ._, ._f, .bs, .dst0q, .src0q, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._s, .bt, .src0q, .ua(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._f, .bs, .dst0q, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi, .false_deps_lzcnt_tzcnt, null },
                    .src_constraints = .{ .{ .remainder_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .xor, .dst0d, .dst0d, ._, ._ },
                        .{ ._, ._, .tzcnt, .dst0q, .memia(.src0q, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._nc, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .sa(.src0, .add_bit_size_sub_8_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .dst0d, .leasia(.dst0, .@"8", .tmp0, .add_8_src0_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi, null, null },
                    .src_constraints = .{ .{ .remainder_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .tzcnt, .dst0q, .memia(.src0q, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._nc, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .sa(.src0, .add_bit_size_sub_8_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .dst0d, .leasia(.dst0, .@"8", .tmp0, .add_8_src0_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bsf_bsr_0_clobbers_result, null, null },
                    .src_constraints = .{ .{ .remainder_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._f, .bs, .dst0q, .memia(.src0q, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._nz, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .sa(.src0, .add_bit_size_sub_8_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .dst0d, .leasia(.dst0, .@"8", .tmp0, .add_8_src0_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .remainder_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .xor, .dst0d, .dst0d, ._, ._ },
                        .{ ._, ._f, .bs, .dst0q, .memia(.src0q, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._nz, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .sa(.src0, .add_bit_size_sub_8_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .dst0d, .leasia(.dst0, .@"8", .tmp0, .add_8_src0_size), ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f}", .{
                        @tagName(air_tag),
                        cg.typeOf(ty_op.operand).fmt(pt),
                        ops[0].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{ty_op.operand}, &ops, cg);
            },
            .popcount => |air_tag| {
                const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                var res: [1]Temp = undefined;
                cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{
                    .src_constraints = .{ .{ .exact_signed_int = 1 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .neg, .dst0b, ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_unsigned_int = 1 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{} },
                }, .{
                    .required_features = .{ .popcnt, null, null, null },
                    .src_constraints = .{ .{ .unsigned_or_exact_int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .dst0d, .src0b, ._, ._ },
                        .{ ._, ._, .popcnt, .dst0d, .dst0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .popcnt, null, null, null },
                    .src_constraints = .{ .{ .unsigned_or_exact_int = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                        .{ ._, ._, .popcnt, .dst0w, .src0w, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .popcnt, null, null, null },
                    .src_constraints = .{ .{ .unsigned_or_exact_int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .popcnt, .dst0d, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .popcnt, .false_deps_popcnt, null, null },
                    .src_constraints = .{ .{ .unsigned_or_exact_int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                        .{ ._, ._, .popcnt, .dst0d, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .popcnt, null, null, null },
                    .src_constraints = .{ .{ .unsigned_or_exact_int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .popcnt, .dst0d, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .popcnt, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._l, .sh, .src0d, .uia(32, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .popcnt, .dst0d, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .popcnt, null, null },
                    .src_constraints = .{ .{ .unsigned_or_exact_int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .popcnt, .dst0q, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .popcnt, .false_deps_popcnt, null },
                    .src_constraints = .{ .{ .unsigned_or_exact_int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                        .{ ._, ._, .popcnt, .dst0q, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .popcnt, null, null },
                    .src_constraints = .{ .{ .unsigned_or_exact_int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .popcnt, .dst0q, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .popcnt, null, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._l, .sh, .src0q, .uia(64, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .popcnt, .dst0q, .src0q, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_or_exact_int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sh, .src0b, .ui(1), ._, ._ },
                        .{ ._, ._, .@"and", .src0b, .ui(0x55), ._, ._ },
                        .{ ._, ._, .sub, .tmp0b, .src0b, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(2), ._, ._ },
                        .{ ._, ._, .@"and", .dst0b, .ui(0x33), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0b, .ui(0x33), ._, ._ },
                        .{ ._, ._, .add, .dst0b, .tmp0b, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sh, .dst0b, .ui(4), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0b, .ui(0x0f), ._, ._ },
                        .{ ._, ._, .add, .dst0b, .tmp0b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._l, .sh, .src0b, .uia(8, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sh, .src0b, .ui(1), ._, ._ },
                        .{ ._, ._, .@"and", .src0b, .ui(0x55), ._, ._ },
                        .{ ._, ._, .sub, .tmp0b, .src0b, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(2), ._, ._ },
                        .{ ._, ._, .@"and", .dst0b, .ui(0x33), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0b, .ui(0x33), ._, ._ },
                        .{ ._, ._, .add, .dst0b, .tmp0b, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sh, .dst0b, .ui(4), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0b, .ui(0x0f), ._, ._ },
                        .{ ._, ._, .add, .dst0b, .tmp0b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{ .{ .unsigned_or_exact_int = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sh, .src0d, .ui(1), ._, ._ },
                        .{ ._, ._, .@"and", .src0w, .ui(0x5555), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(2), ._, ._ },
                        .{ ._, ._, .@"and", .dst0w, .ui(0x3333), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0w, .ui(0x3333), ._, ._ },
                        .{ ._, ._, .lea, .dst0d, .leai(.dst0, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sh, .dst0d, .ui(4), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0w, .ui(0x0f0f), ._, ._ },
                        .{ ._, ._, .@"and", .dst0w, .ui(0x0f0f), ._, ._ },
                        .{ ._, ._, .lea, .tmp0d, .leai(.tmp0, .dst0), ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(8), ._, ._ },
                        .{ ._, ._, .add, .dst0b, .tmp0b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._l, .sh, .src0d, .uia(16, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sh, .src0d, .ui(1), ._, ._ },
                        .{ ._, ._, .@"and", .src0w, .ui(0x5555), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(2), ._, ._ },
                        .{ ._, ._, .@"and", .dst0w, .ui(0x3333), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0w, .ui(0x3333), ._, ._ },
                        .{ ._, ._, .lea, .dst0d, .leai(.dst0, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sh, .dst0d, .ui(4), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0w, .ui(0x0f0f), ._, ._ },
                        .{ ._, ._, .@"and", .dst0w, .ui(0x0f0f), ._, ._ },
                        .{ ._, ._, .lea, .tmp0d, .leai(.tmp0, .dst0), ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(8), ._, ._ },
                        .{ ._, ._, .add, .dst0b, .tmp0b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_or_exact_int = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sh, .src0d, .ui(1), ._, ._ },
                        .{ ._, ._, .@"and", .src0d, .ui(0x5555), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(2), ._, ._ },
                        .{ ._, ._, .@"and", .dst0d, .ui(0x3333), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0d, .ui(0x3333), ._, ._ },
                        .{ ._, ._, .lea, .dst0d, .leai(.dst0, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sh, .dst0d, .ui(4), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0d, .ui(0x0f0f), ._, ._ },
                        .{ ._, ._, .@"and", .dst0d, .ui(0x0f0f), ._, ._ },
                        .{ ._, ._, .lea, .tmp0d, .leai(.tmp0, .dst0), ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(8), ._, ._ },
                        .{ ._, ._, .add, .dst0b, .tmp0b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._l, .sh, .src0d, .uia(16, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sh, .src0d, .ui(1), ._, ._ },
                        .{ ._, ._, .@"and", .src0d, .ui(0x5555), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(2), ._, ._ },
                        .{ ._, ._, .@"and", .dst0d, .ui(0x3333), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0d, .ui(0x3333), ._, ._ },
                        .{ ._, ._, .lea, .dst0d, .leai(.dst0, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sh, .dst0d, .ui(4), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0d, .ui(0x0f0f), ._, ._ },
                        .{ ._, ._, .@"and", .dst0d, .ui(0x0f0f), ._, ._ },
                        .{ ._, ._, .lea, .tmp0d, .leai(.tmp0, .dst0), ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(8), ._, ._ },
                        .{ ._, ._, .add, .dst0b, .tmp0b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_or_exact_int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sh, .src0d, .ui(1), ._, ._ },
                        .{ ._, ._, .@"and", .src0d, .ui(0x55555555), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(2), ._, ._ },
                        .{ ._, ._, .@"and", .dst0d, .ui(0x33333333), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0d, .ui(0x33333333), ._, ._ },
                        .{ ._, ._, .lea, .dst0d, .leai(.dst0, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sh, .dst0d, .ui(4), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0d, .ui(0x0f0f0f0f), ._, ._ },
                        .{ ._, ._, .@"and", .dst0d, .ui(0x0f0f0f0f), ._, ._ },
                        .{ ._, ._, .lea, .tmp0d, .leai(.tmp0, .dst0), ._, ._ },
                        .{ ._, .i_, .mul, .dst0d, .tmp0d, .ui(0x01010101), ._ },
                        .{ ._, ._r, .sh, .dst0d, .ui(32 - 8), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._l, .sh, .src0d, .uia(32, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sh, .src0d, .ui(1), ._, ._ },
                        .{ ._, ._, .@"and", .src0d, .ui(0x55555555), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._, .mov, .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(2), ._, ._ },
                        .{ ._, ._, .@"and", .dst0d, .ui(0x33333333), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0d, .ui(0x33333333), ._, ._ },
                        .{ ._, ._, .lea, .dst0d, .leai(.dst0, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sh, .dst0d, .ui(4), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0d, .ui(0x0f0f0f0f), ._, ._ },
                        .{ ._, ._, .@"and", .dst0d, .ui(0x0f0f0f0f), ._, ._ },
                        .{ ._, ._, .lea, .tmp0d, .leai(.tmp0, .dst0), ._, ._ },
                        .{ ._, .i_, .mul, .dst0d, .tmp0d, .ui(0x01010101), ._ },
                        .{ ._, ._r, .sh, .dst0d, .ui(32 - 8), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .unsigned_or_exact_int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ },
                        .{ ._, ._r, .sh, .src0q, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .uia(0x55555555, .none, .repeat), ._, ._ },
                        .{ ._, ._, .@"and", .src0q, .tmp1q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0q, .src0q, ._, ._ },
                        .{ ._, ._, .mov, .dst0q, .tmp0q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0q, .ui(2), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .uia(0x33333333, .none, .repeat), ._, ._ },
                        .{ ._, ._, .@"and", .dst0q, .tmp1q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._, .lea, .dst0q, .leai(.dst0, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ },
                        .{ ._, ._r, .sh, .dst0q, .ui(4), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .uia(0x0f0f0f0f, .none, .repeat), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._, .@"and", .dst0q, .tmp1q, ._, ._ },
                        .{ ._, ._, .lea, .dst0q, .leai(.dst0, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .uia(0x01010101, .none, .repeat), ._, ._ },
                        .{ ._, .i_, .mul, .dst0q, .tmp1q, ._, ._ },
                        .{ ._, ._r, .sh, .dst0q, .ui(64 - 8), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._l, .sh, .src0q, .uia(64, .src0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ },
                        .{ ._, ._r, .sh, .src0q, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .uia(0x55555555, .none, .repeat), ._, ._ },
                        .{ ._, ._, .@"and", .src0q, .tmp1q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0q, .src0q, ._, ._ },
                        .{ ._, ._, .mov, .dst0q, .tmp0q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0q, .ui(2), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .uia(0x33333333, .none, .repeat), ._, ._ },
                        .{ ._, ._, .@"and", .dst0q, .tmp1q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._, .lea, .dst0q, .leai(.dst0, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ },
                        .{ ._, ._r, .sh, .dst0q, .ui(4), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .uia(0x0f0f0f0f, .none, .repeat), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._, .@"and", .dst0q, .tmp1q, ._, ._ },
                        .{ ._, ._, .lea, .dst0q, .leai(.dst0, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .uia(0x01010101, .none, .repeat), ._, ._ },
                        .{ ._, .i_, .mul, .dst0q, .tmp1q, ._, ._ },
                        .{ ._, ._r, .sh, .dst0q, .ui(64 - 8), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .popcnt, .false_deps_popcnt, null },
                    .src_constraints = .{ .{ .unsigned_or_exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
                        .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                        .{ .@"0:", ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._, .popcnt, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .dst0d, .leai(.dst0, .tmp1), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .popcnt, null, null },
                    .src_constraints = .{ .{ .unsigned_or_exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
                        .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                        .{ .@"0:", ._, .popcnt, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .dst0d, .leai(.dst0, .tmp1), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .popcnt, .false_deps_popcnt, null },
                    .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0q, .memad(.src0q, .add_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-24, .src0, .add_size), ._, ._ },
                        .{ ._, ._l, .sh, .dst0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .popcnt, .dst0q, .dst0q, ._, ._ },
                        .{ .@"0:", ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._, .popcnt, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .dst0d, .leai(.dst0, .tmp1), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .popcnt, null, null },
                    .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0q, .memad(.src0q, .add_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-24, .src0, .add_size), ._, ._ },
                        .{ ._, ._l, .sh, .dst0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .popcnt, .dst0q, .dst0q, ._, ._ },
                        .{ .@"0:", ._, .popcnt, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .dst0d, .leai(.dst0, .tmp1), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .popcnt, .false_deps_popcnt, null },
                    .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ },
                        .{ ._, ._l, .sh, .dst0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .popcnt, .dst0q, .dst0q, ._, ._ },
                        .{ .@"0:", ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._, .popcnt, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .dst0d, .leai(.dst0, .tmp1), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .popcnt, null, null },
                    .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ },
                        .{ ._, ._l, .sh, .dst0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .popcnt, .dst0q, .dst0q, ._, ._ },
                        .{ .@"0:", ._, .popcnt, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .dst0d, .leai(.dst0, .tmp1), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .unsigned_or_exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
                        .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp1q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp1q, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .uia(0x55555555, .none, .repeat), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._, .sub, .tmp2q, .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .tmp2q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp2q, .ui(2), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .uia(0x33333333, .none, .repeat), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp2q, .tmp3q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .leai(.tmp1, .tmp2), ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp1q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp1q, .ui(4), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .uia(0x0f0f0f0f, .none, .repeat), ._, ._ },
                        .{ ._, ._, .@"and", .tmp2q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .leai(.tmp1, .tmp2), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .uia(0x01010101, .none, .repeat), ._, ._ },
                        .{ ._, .i_, .mul, .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp1q, .ui(64 - 8), ._, ._ },
                        .{ ._, ._, .lea, .dst0d, .leai(.dst0, .tmp1), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ },
                        .{ ._, ._l, .sh, .tmp1q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                        .{ ._, ._mp, .j, .@"1f", ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp2q, .tmp1q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp1q, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .uia(0x55555555, .none, .repeat), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._, .sub, .tmp2q, .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .tmp2q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp2q, .ui(2), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .uia(0x33333333, .none, .repeat), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp2q, .tmp3q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .leai(.tmp1, .tmp2), ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp1q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp1q, .ui(4), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .uia(0x0f0f0f0f, .none, .repeat), ._, ._ },
                        .{ ._, ._, .@"and", .tmp2q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .leai(.tmp1, .tmp2), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .uia(0x01010101, .none, .repeat), ._, ._ },
                        .{ ._, .i_, .mul, .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp1q, .ui(64 - 8), ._, ._ },
                        .{ ._, ._, .lea, .dst0d, .leai(.dst0, .tmp1), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
                        .{ ._, ._l, .sh, .tmp1q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                        .{ ._, ._mp, .j, .@"1f", ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp2q, .tmp1q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp1q, .ui(1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .uia(0x55555555, .none, .repeat), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._, .sub, .tmp2q, .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .tmp2q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp2q, .ui(2), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .uia(0x33333333, .none, .repeat), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp2q, .tmp3q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .leai(.tmp1, .tmp2), ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp1q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp1q, .ui(4), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .uia(0x0f0f0f0f, .none, .repeat), ._, ._ },
                        .{ ._, ._, .@"and", .tmp2q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .leai(.tmp1, .tmp2), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .uia(0x01010101, .none, .repeat), ._, ._ },
                        .{ ._, .i_, .mul, .tmp1q, .tmp3q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp1q, .ui(64 - 8), ._, ._ },
                        .{ ._, ._, .lea, .dst0d, .leai(.dst0, .tmp1), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f}", .{
                        @tagName(air_tag),
                        cg.typeOf(ty_op.operand).fmt(pt),
                        ops[0].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{ty_op.operand}, &ops, cg);
            },
            .byte_swap => |air_tag| {
                const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                var res: [1]Temp = undefined;
                cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{
                    .src_constraints = .{ .{ .exact_int = 8 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{} },
                }, .{
                    .required_features = .{ .movbe, null, null, null },
                    .src_constraints = .{ .{ .exact_int = 16 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                        .{ ._, ._be, .mov, .dst0w, .src0w, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_int = 16 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._r, .ro, .dst0w, .ui(8), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .movbe, null, null, null },
                    .src_constraints = .{ .{ .exact_int = 32 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._be, .mov, .dst0d, .src0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_int = 32 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .b_, .swap, .dst0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .movbe, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._be, .mov, .dst0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .b_, .swap, .dst0d, ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .movbe, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._be, .mov, .dst0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sh, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .b_, .swap, .dst0d, ._, ._, ._ },
                        .{ ._, ._r, .sh, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .movbe, null, null, null },
                    .src_constraints = .{ .{ .exact_int = 64 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._be, .mov, .dst0q, .src0q, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_int = 64 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .b_, .swap, .dst0q, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .movbe, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._be, .mov, .dst0q, .src0q, ._, ._ },
                        .{ ._, ._r, .sa, .dst0q, .uia(64, .src0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .b_, .swap, .dst0q, ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0q, .uia(64, .src0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .movbe, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._be, .mov, .dst0q, .src0q, ._, ._ },
                        .{ ._, ._r, .sh, .dst0q, .uia(64, .src0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .b_, .swap, .dst0q, ._, ._, ._ },
                        .{ ._, ._r, .sh, .dst0q, .uia(64, .src0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .movbe, null, null },
                    .src_constraints = .{ .{ .exact_remainder_int = .{ .of = .xword, .is = 128 } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2q, .lea(.tmp1q), ._, ._ },
                        .{ ._, ._be, .mov, .memi(.dst0q, .tmp0), .tmp2q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .exact_remainder_int = .{ .of = .xword, .is = 128 } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2q, .lea(.tmp1q), ._, ._ },
                        .{ ._, .b_, .swap, .tmp2q, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp2q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .movbe, null, null },
                    .src_constraints = .{ .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 64 } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .movsx, .tmp2q, .mem(.src0b), ._, ._ },
                        .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp2q, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2q, .lea(.tmp1q), ._, ._ },
                        .{ ._, ._be, .mov, .memi(.dst0q, .tmp0), .tmp2q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 64 } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .movsx, .tmp2q, .mem(.src0b), ._, ._ },
                        .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp2q, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2q, .lea(.tmp1q), ._, ._ },
                        .{ ._, .b_, .swap, .tmp2q, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp2q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .movbe, null, null },
                    .src_constraints = .{ .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2q, .lea(.tmp1q), ._, ._ },
                        .{ ._, ._be, .mov, .memi(.dst0q, .tmp0), .tmp2q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2q, .lea(.tmp1q), ._, ._ },
                        .{ ._, .b_, .swap, .tmp2q, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp2q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .movbe, null, null },
                    .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .movsx, .tmp2q, .mem(.src0b), ._, ._ },
                        .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp2q, ._, ._ },
                        .{ .@"0:", ._be, .mov, .tmp3q, .lea(.tmp1q), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp3q, ._, ._ },
                        .{ ._, ._rd, .sh, .tmp3q, .tmp2q, .uia(64, .src0, .sub_bit_size_rem_64), ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .movsx, .tmp2q, .mem(.src0b), ._, ._ },
                        .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp2q, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp3q, .lea(.tmp1q), ._, ._ },
                        .{ ._, .b_, .swap, .tmp3q, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp3q, ._, ._ },
                        .{ ._, ._rd, .sh, .tmp3q, .tmp2q, .uia(64, .src0, .sub_bit_size_rem_64), ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .movbe, null, null },
                    .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp2q, ._, ._ },
                        .{ .@"0:", ._be, .mov, .tmp3q, .lea(.tmp1q), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp3q, ._, ._ },
                        .{ ._, ._rd, .sh, .tmp3q, .tmp2q, .uia(64, .src0, .sub_bit_size_rem_64), ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp2q, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp3q, .lea(.tmp1q), ._, ._ },
                        .{ ._, .b_, .swap, .tmp3q, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp3q, ._, ._ },
                        .{ ._, ._rd, .sh, .tmp3q, .tmp2q, .uia(64, .src0, .sub_bit_size_rem_64), ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .movbe, null, null },
                    .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .movsx, .tmp2q, .mem(.src0b), ._, ._ },
                        .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ },
                        .{ .@"0:", ._be, .mov, .tmp3q, .lea(.tmp1q), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp3q, ._, ._ },
                        .{ ._, ._rd, .sh, .tmp3q, .tmp2q, .uia(64, .src0, .sub_bit_size_rem_64), ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .movsx, .tmp2q, .mem(.src0b), ._, ._ },
                        .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp3q, .lea(.tmp1q), ._, ._ },
                        .{ ._, .b_, .swap, .tmp3q, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp3q, ._, ._ },
                        .{ ._, ._rd, .sh, .tmp3q, .tmp2q, .uia(64, .src0, .sub_bit_size_rem_64), ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .movbe, null, null },
                    .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"0:", ._be, .mov, .tmp3q, .lea(.tmp1q), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp3q, ._, ._ },
                        .{ ._, ._rd, .sh, .tmp3q, .tmp2q, .uia(64, .src0, .sub_bit_size_rem_64), ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp3q, .lea(.tmp1q), ._, ._ },
                        .{ ._, .b_, .swap, .tmp3q, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .tmp3q, ._, ._ },
                        .{ ._, ._rd, .sh, .tmp3q, .tmp2q, .uia(64, .src0, .sub_bit_size_rem_64), ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f}", .{
                        @tagName(air_tag),
                        ty_op.ty.toType().fmt(pt),
                        ops[0].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{ty_op.operand}, &ops, cg);
            },
            .bit_reverse => |air_tag| {
                const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                var res: [1]Temp = undefined;
                cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{
                    .src_constraints = .{ .{ .exact_int = 1 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{} },
                }, .{
                    .required_features = .{ .avx, .gfni, null, null },
                    .src_constraints = .{ .{ .exact_int = 8 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ },
                        .{ ._, .v_b, .gf2p8affineq, .dst0x, .src0x, .lea(.tmp1x), .ui(0) },
                    } },
                }, .{
                    .required_features = .{ .gfni, null, null, null },
                    .src_constraints = .{ .{ .exact_int = 8 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ },
                        .{ ._, ._b, .gf2p8affineq, .dst0x, .lea(.tmp1x), .ui(0), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .exact_int = 8 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .reverse } },
                        .{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ },
                        .{ ._, .vp_b, .broadcast, .tmp1x, .src0x, ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp2x, .lea(.dst0x), ._, ._ },
                        .{ ._, .vp_, .@"and", .tmp1x, .tmp1x, .tmp2x, ._ },
                        .{ ._, .vp_b, .cmpeq, .tmp1x, .tmp1x, .tmp2x, ._ },
                        .{ ._, .vp_b, .movmsk, .dst0d, .tmp1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .exact_int = 8 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .reverse } },
                        .{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ },
                        .{ ._, .vp_b, .shuf, .tmp1x, .src0x, .tmp2x, ._ },
                        .{ ._, .v_dqa, .mov, .tmp2x, .lea(.dst0x), ._, ._ },
                        .{ ._, .vp_, .@"and", .tmp1x, .tmp1x, .tmp2x, ._ },
                        .{ ._, .vp_b, .cmpeq, .tmp1x, .tmp1x, .tmp2x, ._ },
                        .{ ._, .vp_b, .movmsk, .dst0d, .tmp1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .ssse3, null, null, null },
                    .src_constraints = .{ .{ .exact_int = 8 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .reverse } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ },
                        .{ ._, .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_b, .shuf, .src0x, .tmp1x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp1x, .lea(.dst0x), ._, ._ },
                        .{ ._, .p_, .@"and", .src0x, .tmp1x, ._, ._ },
                        .{ ._, .p_b, .cmpeq, .src0x, .tmp1x, ._, ._ },
                        .{ ._, .p_b, .movmsk, .dst0d, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .exact_int = 8 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .reverse } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ },
                        .{ ._, .p_, .unpcklbw, .src0x, .src0x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp1x, .lea(.dst0x), ._, ._ },
                        .{ ._, .p_w, .shufl, .src0x, .src0x, .ui(0b00_00_00_00), ._ },
                        .{ ._, .p_, .@"and", .src0x, .tmp1x, ._, ._ },
                        .{ ._, .p_b, .cmpeq, .src0x, .tmp1x, ._, ._ },
                        .{ ._, .p_b, .movmsk, .dst0d, .src0x, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_int = 8 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sh, .src0b, .ui(4), ._, ._ },
                        .{ ._, ._l, .sh, .tmp0b, .ui(4), ._, ._ },
                        .{ ._, ._, .@"or", .dst0b, .tmp0b, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sh, .dst0b, .ui(2), ._, ._ },
                        .{ ._, ._l, .sh, .tmp0b, .ui(2), ._, ._ },
                        .{ ._, ._, .@"and", .dst0b, .ui(0b00110011), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0b, .ui(0b11001100), ._, ._ },
                        .{ ._, ._, .@"or", .dst0b, .tmp0b, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sh, .dst0b, .ui(1), ._, ._ },
                        .{ ._, ._l, .sh, .tmp0b, .ui(1), ._, ._ },
                        .{ ._, ._, .@"and", .dst0b, .ui(0b01010101), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0b, .ui(0b10101010), ._, ._ },
                        .{ ._, ._, .@"or", .dst0b, .tmp0b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, .gfni, null, null },
                    .src_constraints = .{ .{ .signed_int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ },
                        .{ ._, .v_b, .gf2p8affineq, .dst0x, .src0x, .lea(.tmp1x), .ui(0) },
                        .{ ._, .vp_, .unpcklbw, .dst0x, .dst0x, .dst0x, ._ },
                        .{ ._, .vp_w, .sra, .dst0x, .dst0x, .uia(16, .dst0, .sub_bit_size), ._ },
                    } },
                }, .{
                    .required_features = .{ .gfni, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ },
                        .{ ._, ._b, .gf2p8affineq, .src0x, .lea(.tmp1x), .ui(0), ._ },
                        .{ ._, .p_, .unpcklbw, .src0x, .src0x, ._, ._ },
                        .{ ._, .p_w, .sra, .src0x, .uia(16, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .reverse } },
                        .{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ },
                        .{ ._, .vp_b, .broadcast, .tmp1x, .src0x, ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp2x, .lea(.dst0x), ._, ._ },
                        .{ ._, .vp_, .@"and", .tmp1x, .tmp1x, .tmp2x, ._ },
                        .{ ._, .vp_b, .cmpeq, .tmp1x, .tmp1x, .tmp2x, ._ },
                        .{ ._, .vp_b, .movmsk, .dst0d, .tmp1x, ._, ._ },
                        .{ ._, ._r, .sa, .dst0b, .uia(8, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .reverse } },
                        .{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ },
                        .{ ._, .vp_b, .shuf, .tmp1x, .src0x, .tmp2x, ._ },
                        .{ ._, .v_dqa, .mov, .tmp2x, .lea(.dst0x), ._, ._ },
                        .{ ._, .vp_, .@"and", .tmp1x, .tmp1x, .tmp2x, ._ },
                        .{ ._, .vp_b, .cmpeq, .tmp1x, .tmp1x, .tmp2x, ._ },
                        .{ ._, .vp_b, .movmsk, .dst0d, .tmp1x, ._, ._ },
                        .{ ._, ._r, .sa, .dst0b, .uia(8, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .ssse3, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .reverse } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ },
                        .{ ._, .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_b, .shuf, .src0x, .tmp1x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp1x, .lea(.dst0x), ._, ._ },
                        .{ ._, .p_, .@"and", .src0x, .tmp1x, ._, ._ },
                        .{ ._, .p_b, .cmpeq, .src0x, .tmp1x, ._, ._ },
                        .{ ._, .p_b, .movmsk, .dst0d, .src0x, ._, ._ },
                        .{ ._, ._r, .sa, .dst0b, .uia(8, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .reverse } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ },
                        .{ ._, .p_, .unpcklbw, .src0x, .src0x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp1x, .lea(.dst0x), ._, ._ },
                        .{ ._, .p_w, .shufl, .src0x, .src0x, .ui(0b00_00_00_00), ._ },
                        .{ ._, .p_, .@"and", .src0x, .tmp1x, ._, ._ },
                        .{ ._, .p_b, .cmpeq, .src0x, .tmp1x, ._, ._ },
                        .{ ._, .p_b, .movmsk, .dst0d, .src0x, ._, ._ },
                        .{ ._, ._r, .sa, .dst0b, .uia(8, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sh, .src0b, .ui(4), ._, ._ },
                        .{ ._, ._l, .sh, .tmp0b, .ui(4), ._, ._ },
                        .{ ._, ._, .@"or", .dst0b, .tmp0b, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sh, .dst0b, .ui(2), ._, ._ },
                        .{ ._, ._l, .sh, .tmp0b, .ui(2), ._, ._ },
                        .{ ._, ._, .@"and", .dst0b, .ui(0b00110011), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0b, .ui(0b11001100), ._, ._ },
                        .{ ._, ._, .@"or", .dst0b, .tmp0b, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sh, .dst0b, .ui(1), ._, ._ },
                        .{ ._, ._l, .sh, .tmp0b, .ui(1), ._, ._ },
                        .{ ._, ._, .@"and", .dst0b, .ui(0b01010101), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0b, .ui(0b10101010), ._, ._ },
                        .{ ._, ._, .@"or", .dst0b, .tmp0b, ._, ._ },
                        .{ ._, ._r, .sa, .dst0b, .uia(8, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, .gfni, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ },
                        .{ ._, .v_b, .gf2p8affineq, .dst0x, .src0x, .lea(.tmp1x), .ui(0) },
                        .{ ._, .vp_, .unpcklbw, .dst0x, .dst0x, .dst0x, ._ },
                        .{ ._, .vp_w, .srl, .dst0x, .dst0x, .uia(16, .dst0, .sub_bit_size), ._ },
                    } },
                }, .{
                    .required_features = .{ .gfni, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ },
                        .{ ._, ._b, .gf2p8affineq, .src0x, .lea(.tmp1x), .ui(0), ._ },
                        .{ ._, .p_, .unpcklbw, .src0x, .src0x, ._, ._ },
                        .{ ._, .p_w, .srl, .src0x, .uia(16, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .reverse } },
                        .{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ },
                        .{ ._, .vp_b, .broadcast, .tmp1x, .src0x, ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp2x, .lea(.dst0x), ._, ._ },
                        .{ ._, .vp_, .@"and", .tmp1x, .tmp1x, .tmp2x, ._ },
                        .{ ._, .vp_b, .cmpeq, .tmp1x, .tmp1x, .tmp2x, ._ },
                        .{ ._, .vp_b, .movmsk, .dst0d, .tmp1x, ._, ._ },
                        .{ ._, ._r, .sh, .dst0b, .uia(8, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .reverse } },
                        .{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ },
                        .{ ._, .vp_b, .shuf, .tmp1x, .src0x, .tmp2x, ._ },
                        .{ ._, .v_dqa, .mov, .tmp2x, .lea(.dst0x), ._, ._ },
                        .{ ._, .vp_, .@"and", .tmp1x, .tmp1x, .tmp2x, ._ },
                        .{ ._, .vp_b, .cmpeq, .tmp1x, .tmp1x, .tmp2x, ._ },
                        .{ ._, .vp_b, .movmsk, .dst0d, .tmp1x, ._, ._ },
                        .{ ._, ._r, .sh, .dst0b, .uia(8, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .ssse3, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .reverse } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ },
                        .{ ._, .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_b, .shuf, .src0x, .tmp1x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp1x, .lea(.dst0x), ._, ._ },
                        .{ ._, .p_, .@"and", .src0x, .tmp1x, ._, ._ },
                        .{ ._, .p_b, .cmpeq, .src0x, .tmp1x, ._, ._ },
                        .{ ._, .p_b, .movmsk, .dst0d, .src0x, ._, ._ },
                        .{ ._, ._r, .sh, .dst0b, .uia(8, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .reverse } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ },
                        .{ ._, .p_, .unpcklbw, .src0x, .src0x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp1x, .lea(.dst0x), ._, ._ },
                        .{ ._, .p_w, .shufl, .src0x, .src0x, .ui(0b00_00_00_00), ._ },
                        .{ ._, .p_, .@"and", .src0x, .tmp1x, ._, ._ },
                        .{ ._, .p_b, .cmpeq, .src0x, .tmp1x, ._, ._ },
                        .{ ._, .p_b, .movmsk, .dst0d, .src0x, ._, ._ },
                        .{ ._, ._r, .sh, .dst0b, .uia(8, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sh, .src0b, .ui(4), ._, ._ },
                        .{ ._, ._l, .sh, .tmp0b, .ui(4), ._, ._ },
                        .{ ._, ._, .@"or", .dst0b, .tmp0b, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sh, .dst0b, .ui(2), ._, ._ },
                        .{ ._, ._l, .sh, .tmp0b, .ui(2), ._, ._ },
                        .{ ._, ._, .@"and", .dst0b, .ui(0b00110011), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0b, .ui(0b11001100), ._, ._ },
                        .{ ._, ._, .@"or", .dst0b, .tmp0b, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sh, .dst0b, .ui(1), ._, ._ },
                        .{ ._, ._l, .sh, .tmp0b, .ui(1), ._, ._ },
                        .{ ._, ._, .@"and", .dst0b, .ui(0b01010101), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0b, .ui(0b10101010), ._, ._ },
                        .{ ._, ._, .@"or", .dst0b, .tmp0b, ._, ._ },
                        .{ ._, ._r, .sh, .dst0b, .uia(8, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, .gfni, null, null },
                    .src_constraints = .{ .{ .exact_int = 16 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word } } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ },
                        .{ ._, .v_b, .gf2p8affineq, .dst0x, .src0x, .lea(.tmp2x), .ui(0) },
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_b, .shuf, .dst0x, .dst0x, .lea(.tmp2x), ._ },
                    } },
                }, .{
                    .required_features = .{ .ssse3, .gfni, null, null },
                    .src_constraints = .{ .{ .exact_int = 16 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word } } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ },
                        .{ ._, ._b, .gf2p8affineq, .dst0x, .lea(.tmp2x), .ui(0), ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_b, .shuf, .dst0x, .lea(.tmp2x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .gfni, null, null, null },
                    .src_constraints = .{ .{ .exact_int = 16 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ },
                        .{ ._, ._b, .gf2p8affineq, .dst0x, .lea(.tmp1x), .ui(0), ._ },
                        .{ ._, .p_, .unpcklwd, .dst0x, .dst0x, ._, ._ },
                        .{ ._, .p_dq, .srl, .dst0x, .ui(1), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .exact_int = 16 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word, .smear = 8 } } },
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .reverse } },
                        .{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ },
                        .{ ._, .vp_b, .shuf, .tmp2x, .src0x, .lea(.dst0x), ._ },
                        .{ ._, ._, .lea, .dst0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp3x, .lea(.dst0x), ._, ._ },
                        .{ ._, .vp_, .@"and", .tmp2x, .tmp2x, .tmp3x, ._ },
                        .{ ._, .vp_b, .cmpeq, .tmp2x, .tmp2x, .tmp3x, ._ },
                        .{ ._, .vp_b, .movmsk, .dst0d, .tmp2x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .ssse3, null, null, null },
                    .src_constraints = .{ .{ .exact_int = 16 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word, .smear = 8 } } },
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .reverse } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ },
                        .{ ._, .p_b, .shuf, .src0x, .lea(.dst0x), ._, ._ },
                        .{ ._, ._, .lea, .dst0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .lea(.dst0x), ._, ._ },
                        .{ ._, .p_, .@"and", .src0x, .tmp2x, ._, ._ },
                        .{ ._, .p_b, .cmpeq, .src0x, .tmp2x, ._, ._ },
                        .{ ._, .p_b, .movmsk, .dst0d, .src0x, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_int = 16 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._r, .ro, .src0w, .ui(8), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sh, .src0d, .ui(4), ._, ._ },
                        .{ ._, ._l, .sh, .tmp0d, .ui(4), ._, ._ },
                        .{ ._, ._, .@"and", .src0d, .ui(0b0000111100001111), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0d, .ui(0b1111000011110000), ._, ._ },
                        .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sh, .dst0d, .ui(2), ._, ._ },
                        .{ ._, ._l, .sh, .tmp0d, .ui(2), ._, ._ },
                        .{ ._, ._, .@"and", .dst0d, .ui(0b0011001100110011), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0d, .ui(0b1100110011001100), ._, ._ },
                        .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sh, .dst0d, .ui(1), ._, ._ },
                        .{ ._, ._l, .sh, .tmp0d, .ui(1), ._, ._ },
                        .{ ._, ._, .@"and", .dst0d, .ui(0b0101010101010101), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0d, .ui(0b1010101010101010), ._, ._ },
                        .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, .gfni, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word } } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ },
                        .{ ._, .v_b, .gf2p8affineq, .dst0x, .src0x, .lea(.tmp2x), .ui(0) },
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_b, .shuf, .dst0x, .dst0x, .lea(.tmp2x), ._ },
                        .{ ._, .vp_w, .sra, .dst0x, .dst0x, .uia(16, .dst0, .sub_bit_size), ._ },
                    } },
                }, .{
                    .required_features = .{ .ssse3, .gfni, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word } } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ },
                        .{ ._, ._b, .gf2p8affineq, .dst0x, .lea(.tmp2x), .ui(0), ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_b, .shuf, .dst0x, .lea(.tmp2x), ._, ._ },
                        .{ ._, .p_w, .sra, .dst0x, .uia(16, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .gfni, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ },
                        .{ ._, ._b, .gf2p8affineq, .dst0x, .lea(.tmp1x), .ui(0), ._ },
                        .{ ._, .p_, .unpcklwd, .dst0x, .dst0x, ._, ._ },
                        .{ ._, .p_dq, .srl, .dst0x, .ui(1), ._, ._ },
                        .{ ._, .p_w, .sra, .dst0x, .uia(16, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word, .smear = 8 } } },
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .reverse } },
                        .{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ },
                        .{ ._, .vp_b, .shuf, .tmp2x, .src0x, .lea(.dst0x), ._ },
                        .{ ._, ._, .lea, .dst0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp3x, .lea(.dst0x), ._, ._ },
                        .{ ._, .vp_, .@"and", .tmp2x, .tmp2x, .tmp3x, ._ },
                        .{ ._, .vp_b, .cmpeq, .tmp2x, .tmp2x, .tmp3x, ._ },
                        .{ ._, .vp_b, .movmsk, .dst0d, .tmp2x, ._, ._ },
                        .{ ._, ._r, .sa, .dst0w, .uia(16, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .ssse3, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word, .smear = 8 } } },
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .reverse } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ },
                        .{ ._, .p_b, .shuf, .src0x, .lea(.dst0x), ._, ._ },
                        .{ ._, ._, .lea, .dst0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .lea(.dst0x), ._, ._ },
                        .{ ._, .p_, .@"and", .src0x, .tmp2x, ._, ._ },
                        .{ ._, .p_b, .cmpeq, .src0x, .tmp2x, ._, ._ },
                        .{ ._, .p_b, .movmsk, .dst0d, .src0x, ._, ._ },
                        .{ ._, ._r, .sa, .dst0w, .uia(16, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._r, .ro, .src0w, .ui(8), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sh, .src0d, .ui(4), ._, ._ },
                        .{ ._, ._l, .sh, .tmp0d, .ui(4), ._, ._ },
                        .{ ._, ._, .@"and", .src0d, .ui(0b0000111100001111), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0d, .ui(0b1111000011110000), ._, ._ },
                        .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sh, .dst0d, .ui(2), ._, ._ },
                        .{ ._, ._l, .sh, .tmp0d, .ui(2), ._, ._ },
                        .{ ._, ._, .@"and", .dst0d, .ui(0b0011001100110011), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0d, .ui(0b1100110011001100), ._, ._ },
                        .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sh, .dst0d, .ui(1), ._, ._ },
                        .{ ._, ._l, .sh, .tmp0d, .ui(1), ._, ._ },
                        .{ ._, ._, .@"and", .dst0d, .ui(0b0101010101010101), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0d, .ui(0b1010101010101010), ._, ._ },
                        .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .sa, .dst0w, .uia(16, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, .gfni, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word } } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ },
                        .{ ._, .v_b, .gf2p8affineq, .dst0x, .src0x, .lea(.tmp2x), .ui(0) },
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_b, .shuf, .dst0x, .dst0x, .lea(.tmp2x), ._ },
                        .{ ._, .vp_w, .srl, .dst0x, .dst0x, .uia(16, .dst0, .sub_bit_size), ._ },
                    } },
                }, .{
                    .required_features = .{ .ssse3, .gfni, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word } } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ },
                        .{ ._, ._b, .gf2p8affineq, .dst0x, .lea(.tmp2x), .ui(0), ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_b, .shuf, .dst0x, .lea(.tmp2x), ._, ._ },
                        .{ ._, .p_w, .srl, .dst0x, .uia(16, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .gfni, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ },
                        .{ ._, ._b, .gf2p8affineq, .dst0x, .lea(.tmp1x), .ui(0), ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
                        .{ ._, .p_w, .srl, .dst0x, .uia(24, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, .p_w, .sll, .tmp2x, .sia(-8, .dst0, .add_bit_size), ._, ._ },
                        .{ ._, .p_, .@"or", .dst0x, .tmp2x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word, .smear = 8 } } },
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .reverse } },
                        .{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ },
                        .{ ._, .vp_b, .shuf, .tmp2x, .src0x, .lea(.dst0x), ._ },
                        .{ ._, ._, .lea, .dst0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp3x, .lea(.dst0x), ._, ._ },
                        .{ ._, .vp_, .@"and", .tmp2x, .tmp2x, .tmp3x, ._ },
                        .{ ._, .vp_b, .cmpeq, .tmp2x, .tmp2x, .tmp3x, ._ },
                        .{ ._, .vp_b, .movmsk, .dst0d, .tmp2x, ._, ._ },
                        .{ ._, ._r, .sh, .dst0d, .uia(16, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .ssse3, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word, .smear = 8 } } },
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .reverse } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ },
                        .{ ._, .p_b, .shuf, .src0x, .lea(.dst0x), ._, ._ },
                        .{ ._, ._, .lea, .dst0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .lea(.dst0x), ._, ._ },
                        .{ ._, .p_, .@"and", .src0x, .tmp2x, ._, ._ },
                        .{ ._, .p_b, .cmpeq, .src0x, .tmp2x, ._, ._ },
                        .{ ._, .p_b, .movmsk, .dst0d, .src0x, ._, ._ },
                        .{ ._, ._r, .sh, .dst0w, .uia(16, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._r, .ro, .src0w, .ui(8), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sh, .src0d, .ui(4), ._, ._ },
                        .{ ._, ._l, .sh, .tmp0d, .ui(4), ._, ._ },
                        .{ ._, ._, .@"and", .src0d, .ui(0b0000111100001111), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0d, .ui(0b1111000011110000), ._, ._ },
                        .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sh, .dst0d, .ui(2), ._, ._ },
                        .{ ._, ._l, .sh, .tmp0d, .ui(2), ._, ._ },
                        .{ ._, ._, .@"and", .dst0d, .ui(0b0011001100110011), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0d, .ui(0b1100110011001100), ._, ._ },
                        .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sh, .dst0d, .ui(1), ._, ._ },
                        .{ ._, ._l, .sh, .tmp0d, .ui(1), ._, ._ },
                        .{ ._, ._, .@"and", .dst0d, .ui(0b0101010101010101), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0d, .ui(0b1010101010101010), ._, ._ },
                        .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .sh, .dst0d, .uia(16, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, .gfni, null, null },
                    .src_constraints = .{ .{ .exact_int = 32 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .dword } } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ },
                        .{ ._, .v_b, .gf2p8affineq, .dst0x, .src0x, .lea(.tmp2x), .ui(0) },
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_b, .shuf, .dst0x, .dst0x, .lea(.tmp2x), ._ },
                    } },
                }, .{
                    .required_features = .{ .ssse3, .gfni, null, null },
                    .src_constraints = .{ .{ .exact_int = 32 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .dword } } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ },
                        .{ ._, ._b, .gf2p8affineq, .dst0x, .lea(.tmp2x), .ui(0), ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_b, .shuf, .dst0x, .lea(.tmp2x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .gfni, null, null, null },
                    .src_constraints = .{ .{ .exact_int = 32 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ },
                        .{ ._, ._b, .gf2p8affineq, .dst0x, .lea(.tmp1x), .ui(0), ._ },
                        .{ ._, .p_, .unpcklwd, .dst0x, .dst0x, ._, ._ },
                        .{ ._, .p_dq, .srl, .dst0x, .ui(1), ._, ._ },
                        .{ ._, .p_w, .shufl, .dst0x, .dst0x, .ui(0b00_10_00_10), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .exact_int = 32 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_32_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .dword, .smear = 8 } } },
                        .{ .type = .vector_32_u8, .kind = .{ .bits_mem = .reverse } },
                        .{ .type = .vector_32_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ },
                        .{ ._, .vp_d, .broadcast, .tmp2y, .src0x, ._, ._ },
                        .{ ._, .vp_b, .shuf, .tmp2y, .tmp2y, .lea(.dst0y), ._ },
                        .{ ._, ._, .lea, .dst0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp3y, .lea(.dst0y), ._, ._ },
                        .{ ._, .vp_, .@"and", .tmp2y, .tmp2y, .tmp3y, ._ },
                        .{ ._, .vp_b, .cmpeq, .tmp2y, .tmp2y, .tmp3y, ._ },
                        .{ ._, .vp_b, .movmsk, .dst0d, .tmp2y, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .exact_int = 32 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .b_, .swap, .src0d, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sh, .src0d, .ui(4), ._, ._ },
                        .{ ._, ._l, .sh, .tmp0d, .ui(4), ._, ._ },
                        .{ ._, ._, .@"and", .src0d, .ui(0b00001111000011110000111100001111), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0d, .ui(0b11110000111100001111000011110000), ._, ._ },
                        .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sh, .dst0d, .ui(2), ._, ._ },
                        .{ ._, ._l, .sh, .tmp0d, .ui(2), ._, ._ },
                        .{ ._, ._, .@"and", .dst0d, .ui(0b00110011001100110011001100110011), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0d, .ui(0b11001100110011001100110011001100), ._, ._ },
                        .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sh, .dst0d, .ui(1), ._, ._ },
                        .{ ._, ._l, .sh, .tmp0d, .ui(1), ._, ._ },
                        .{ ._, ._, .@"and", .dst0d, .ui(0b01010101010101010101010101010101), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0d, .ui(0b10101010101010101010101010101010), ._, ._ },
                        .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, .gfni, null, null },
                    .src_constraints = .{ .{ .signed_int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .dword } } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ },
                        .{ ._, .v_b, .gf2p8affineq, .dst0x, .src0x, .lea(.tmp2x), .ui(0) },
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_b, .shuf, .dst0x, .dst0x, .lea(.tmp2x), ._ },
                        .{ ._, .vp_d, .sra, .dst0x, .dst0x, .uia(32, .dst0, .sub_bit_size), ._ },
                    } },
                }, .{
                    .required_features = .{ .ssse3, .gfni, null, null },
                    .src_constraints = .{ .{ .signed_int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .dword } } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ },
                        .{ ._, ._b, .gf2p8affineq, .dst0x, .lea(.tmp2x), .ui(0), ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_b, .shuf, .dst0x, .lea(.tmp2x), ._, ._ },
                        .{ ._, .p_d, .sra, .dst0x, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .gfni, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ },
                        .{ ._, ._b, .gf2p8affineq, .dst0x, .lea(.tmp1x), .ui(0), ._ },
                        .{ ._, .p_, .unpcklwd, .dst0x, .dst0x, ._, ._ },
                        .{ ._, .p_dq, .srl, .dst0x, .ui(1), ._, ._ },
                        .{ ._, .p_w, .shufl, .dst0x, .dst0x, .ui(0b00_10_00_10), ._ },
                        .{ ._, .p_d, .sra, .dst0x, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_32_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .dword, .smear = 8 } } },
                        .{ .type = .vector_32_u8, .kind = .{ .bits_mem = .reverse } },
                        .{ .type = .vector_32_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ },
                        .{ ._, .vp_d, .broadcast, .tmp2y, .src0x, ._, ._ },
                        .{ ._, .vp_b, .shuf, .tmp2y, .tmp2y, .lea(.dst0y), ._ },
                        .{ ._, ._, .lea, .dst0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp3y, .lea(.dst0y), ._, ._ },
                        .{ ._, .vp_, .@"and", .tmp2y, .tmp2y, .tmp3y, ._ },
                        .{ ._, .vp_b, .cmpeq, .tmp2y, .tmp2y, .tmp3y, ._ },
                        .{ ._, .vp_b, .movmsk, .dst0d, .tmp2y, ._, ._ },
                        .{ ._, ._r, .sa, .dst0d, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .b_, .swap, .src0d, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sh, .src0d, .ui(4), ._, ._ },
                        .{ ._, ._l, .sh, .tmp0d, .ui(4), ._, ._ },
                        .{ ._, ._, .@"and", .src0d, .ui(0b00001111000011110000111100001111), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0d, .ui(0b11110000111100001111000011110000), ._, ._ },
                        .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sh, .dst0d, .ui(2), ._, ._ },
                        .{ ._, ._l, .sh, .tmp0d, .ui(2), ._, ._ },
                        .{ ._, ._, .@"and", .dst0d, .ui(0b00110011001100110011001100110011), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0d, .ui(0b11001100110011001100110011001100), ._, ._ },
                        .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sh, .dst0d, .ui(1), ._, ._ },
                        .{ ._, ._l, .sh, .tmp0d, .ui(1), ._, ._ },
                        .{ ._, ._, .@"and", .dst0d, .ui(0b01010101010101010101010101010101), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0d, .ui(0b10101010101010101010101010101010), ._, ._ },
                        .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .sa, .dst0d, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, .gfni, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .dword } } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ },
                        .{ ._, .v_b, .gf2p8affineq, .dst0x, .src0x, .lea(.tmp2x), .ui(0) },
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_b, .shuf, .dst0x, .dst0x, .lea(.tmp2x), ._ },
                        .{ ._, .vp_d, .srl, .dst0x, .dst0x, .uia(32, .dst0, .sub_bit_size), ._ },
                    } },
                }, .{
                    .required_features = .{ .ssse3, .gfni, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .dword } } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ },
                        .{ ._, ._b, .gf2p8affineq, .dst0x, .lea(.tmp2x), .ui(0), ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_b, .shuf, .dst0x, .lea(.tmp2x), ._, ._ },
                        .{ ._, .p_d, .srl, .dst0x, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .gfni, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ },
                        .{ ._, ._b, .gf2p8affineq, .dst0x, .lea(.tmp1x), .ui(0), ._ },
                        .{ ._, .p_, .unpcklwd, .dst0x, .dst0x, ._, ._ },
                        .{ ._, .p_dq, .srl, .dst0x, .ui(1), ._, ._ },
                        .{ ._, .p_w, .shufl, .dst0x, .dst0x, .ui(0b00_10_00_10), ._ },
                        .{ ._, .p_d, .srl, .dst0x, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_32_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .dword, .smear = 8 } } },
                        .{ .type = .vector_32_u8, .kind = .{ .bits_mem = .reverse } },
                        .{ .type = .vector_32_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ },
                        .{ ._, .vp_d, .broadcast, .tmp2y, .src0x, ._, ._ },
                        .{ ._, .vp_b, .shuf, .tmp2y, .tmp2y, .lea(.dst0y), ._ },
                        .{ ._, ._, .lea, .dst0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp3y, .lea(.dst0y), ._, ._ },
                        .{ ._, .vp_, .@"and", .tmp2y, .tmp2y, .tmp3y, ._ },
                        .{ ._, .vp_b, .cmpeq, .tmp2y, .tmp2y, .tmp3y, ._ },
                        .{ ._, .vp_b, .movmsk, .dst0d, .tmp2y, ._, ._ },
                        .{ ._, ._r, .sh, .dst0d, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .b_, .swap, .src0d, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sh, .src0d, .ui(4), ._, ._ },
                        .{ ._, ._l, .sh, .tmp0d, .ui(4), ._, ._ },
                        .{ ._, ._, .@"and", .src0d, .ui(0b00001111000011110000111100001111), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0d, .ui(0b11110000111100001111000011110000), ._, ._ },
                        .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sh, .dst0d, .ui(2), ._, ._ },
                        .{ ._, ._l, .sh, .tmp0d, .ui(2), ._, ._ },
                        .{ ._, ._, .@"and", .dst0d, .ui(0b00110011001100110011001100110011), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0d, .ui(0b11001100110011001100110011001100), ._, ._ },
                        .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ },
                        .{ ._, ._r, .sh, .dst0d, .ui(1), ._, ._ },
                        .{ ._, ._l, .sh, .tmp0d, .ui(1), ._, ._ },
                        .{ ._, ._, .@"and", .dst0d, .ui(0b01010101010101010101010101010101), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0d, .ui(0b10101010101010101010101010101010), ._, ._ },
                        .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .sh, .dst0d, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, .gfni, null, null },
                    .src_constraints = .{ .{ .exact_int = 64 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .qword } } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ },
                        .{ ._, .v_b, .gf2p8affineq, .dst0x, .src0x, .lea(.tmp2x), .ui(0) },
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_b, .shuf, .dst0x, .dst0x, .lea(.tmp2x), ._ },
                    } },
                }, .{
                    .required_features = .{ .ssse3, .gfni, null, null },
                    .src_constraints = .{ .{ .exact_int = 64 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .qword } } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ },
                        .{ ._, ._b, .gf2p8affineq, .dst0x, .lea(.tmp2x), .ui(0), ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_b, .shuf, .dst0x, .lea(.tmp2x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .gfni, null, null },
                    .src_constraints = .{ .{ .exact_int = 64 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ },
                        .{ ._, ._b, .gf2p8affineq, .src0x, .lea(.dst0x), .ui(0), ._ },
                        .{ ._, ._q, .mov, .dst0q, .src0x, ._, ._ },
                        .{ ._, .b_, .swap, .dst0q, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .exact_int = 64 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .b_, .swap, .src0q, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .uia(0b00001111000011110000111100001111, .none, .repeat), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._r, .sh, .src0q, .ui(4), ._, ._ },
                        .{ ._, ._l, .sh, .tmp0q, .ui(4), ._, ._ },
                        .{ ._, ._, .@"and", .src0q, .tmp1q, ._, ._ },
                        .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .uia(0b00110011001100110011001100110011, .none, .repeat), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._r, .sh, .dst0q, .ui(2), ._, ._ },
                        .{ ._, ._l, .sh, .tmp0q, .ui(2), ._, ._ },
                        .{ ._, ._, .@"and", .dst0q, .tmp1q, ._, ._ },
                        .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .uia(0b01010101010101010101010101010101, .none, .repeat), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._r, .sh, .dst0q, .ui(1), ._, ._ },
                        .{ ._, ._l, .sh, .tmp0q, .ui(1), ._, ._ },
                        .{ ._, ._, .@"and", .dst0q, .tmp1q, ._, ._ },
                        .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, .gfni, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } },
                        .{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ },
                        .{ ._, .v_b, .gf2p8affineq, .tmp1x, .src0x, .lea(.dst0x), .ui(0) },
                        .{ ._, .v_q, .mov, .dst0q, .tmp1x, ._, ._ },
                        .{ ._, .b_, .swap, .dst0q, ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0q, .uia(64, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .gfni, null, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ },
                        .{ ._, ._b, .gf2p8affineq, .src0x, .lea(.dst0x), .ui(0), ._ },
                        .{ ._, ._q, .mov, .dst0q, .src0x, ._, ._ },
                        .{ ._, .b_, .swap, .dst0q, ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0q, .uia(64, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .b_, .swap, .src0q, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .uia(0b00001111000011110000111100001111, .none, .repeat), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._r, .sh, .src0q, .ui(4), ._, ._ },
                        .{ ._, ._l, .sh, .tmp0q, .ui(4), ._, ._ },
                        .{ ._, ._, .@"and", .src0q, .tmp1q, ._, ._ },
                        .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .uia(0b00110011001100110011001100110011, .none, .repeat), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._r, .sh, .dst0q, .ui(2), ._, ._ },
                        .{ ._, ._l, .sh, .tmp0q, .ui(2), ._, ._ },
                        .{ ._, ._, .@"and", .dst0q, .tmp1q, ._, ._ },
                        .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .uia(0b01010101010101010101010101010101, .none, .repeat), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._r, .sh, .dst0q, .ui(1), ._, ._ },
                        .{ ._, ._l, .sh, .tmp0q, .ui(1), ._, ._ },
                        .{ ._, ._, .@"and", .dst0q, .tmp1q, ._, ._ },
                        .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ },
                        .{ ._, ._r, .sa, .dst0q, .uia(64, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, .gfni, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .qword } } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ },
                        .{ ._, .v_b, .gf2p8affineq, .dst0x, .src0x, .lea(.tmp2x), .ui(0) },
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_b, .shuf, .dst0x, .dst0x, .lea(.tmp2x), ._ },
                        .{ ._, .vp_q, .srl, .dst0x, .dst0x, .uia(64, .dst0, .sub_bit_size), ._ },
                    } },
                }, .{
                    .required_features = .{ .ssse3, .gfni, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .qword } } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ },
                        .{ ._, ._b, .gf2p8affineq, .dst0x, .lea(.tmp2x), .ui(0), ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_b, .shuf, .dst0x, .lea(.tmp2x), ._, ._ },
                        .{ ._, .p_q, .srl, .dst0x, .uia(64, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .gfni, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ },
                        .{ ._, ._b, .gf2p8affineq, .src0x, .lea(.dst0x), .ui(0), ._ },
                        .{ ._, ._q, .mov, .dst0q, .src0x, ._, ._ },
                        .{ ._, .b_, .swap, .dst0q, ._, ._, ._ },
                        .{ ._, ._r, .sh, .dst0q, .uia(64, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .b_, .swap, .src0q, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .uia(0b00001111000011110000111100001111, .none, .repeat), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._r, .sh, .src0q, .ui(4), ._, ._ },
                        .{ ._, ._l, .sh, .tmp0q, .ui(4), ._, ._ },
                        .{ ._, ._, .@"and", .src0q, .tmp1q, ._, ._ },
                        .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .uia(0b00110011001100110011001100110011, .none, .repeat), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._r, .sh, .dst0q, .ui(2), ._, ._ },
                        .{ ._, ._l, .sh, .tmp0q, .ui(2), ._, ._ },
                        .{ ._, ._, .@"and", .dst0q, .tmp1q, ._, ._ },
                        .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .uia(0b01010101010101010101010101010101, .none, .repeat), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._r, .sh, .dst0q, .ui(1), ._, ._ },
                        .{ ._, ._l, .sh, .tmp0q, .ui(1), ._, ._ },
                        .{ ._, ._, .@"and", .dst0q, .tmp1q, ._, ._ },
                        .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ },
                        .{ ._, ._r, .sh, .dst0q, .uia(64, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, .gfni, null, null },
                    .src_constraints = .{ .{ .exact_int = 128 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .xword } } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ },
                        .{ ._, .v_b, .gf2p8affineq, .dst0x, .src0x, .lea(.tmp2x), .ui(0) },
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_b, .shuf, .dst0x, .dst0x, .lea(.tmp2x), ._ },
                    } },
                }, .{
                    .required_features = .{ .ssse3, .gfni, null, null },
                    .src_constraints = .{ .{ .exact_int = 128 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .xword } } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ },
                        .{ ._, ._b, .gf2p8affineq, .dst0x, .lea(.tmp2x), .ui(0), ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_b, .shuf, .dst0x, .lea(.tmp2x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, .gfni, null },
                    .src_constraints = .{ .{ .signed_int = .xword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .xword } } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ },
                        .{ ._, .v_b, .gf2p8affineq, .tmp3x, .src0x, .lea(.tmp2x), .ui(0) },
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_b, .shuf, .tmp3x, .tmp3x, .lea(.tmp2x), ._ },
                        .{ ._, .v_q, .mov, .tmp2q, .tmp3x, ._, ._ },
                        .{ ._, .vp_q, .extr, .tmp4q, .tmp3x, .ui(1), ._ },
                        .{ ._, ._rd, .sh, .tmp2q, .tmp4q, .uia(128, .dst0, .sub_bit_size), ._ },
                        .{ ._, ._, .mov, .dst0q, .tmp2q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp4q, .uia(128, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp4q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .ssse3, .gfni, null },
                    .src_constraints = .{ .{ .signed_int = .xword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .xword } } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ },
                        .{ ._, ._b, .gf2p8affineq, .src0x, .lea(.tmp2x), .ui(0), ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_b, .shuf, .src0x, .lea(.tmp2x), ._, ._ },
                        .{ ._, ._q, .mov, .tmp2q, .src0x, ._, ._ },
                        .{ ._, .p_q, .extr, .tmp3q, .src0x, .ui(1), ._ },
                        .{ ._, ._rd, .sh, .tmp2q, .tmp3q, .uia(128, .dst0, .sub_bit_size), ._ },
                        .{ ._, ._, .mov, .dst0q, .tmp2q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .uia(128, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp3q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, .gfni, null },
                    .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .xword } } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ },
                        .{ ._, .v_b, .gf2p8affineq, .tmp3x, .src0x, .lea(.tmp2x), .ui(0) },
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_b, .shuf, .tmp3x, .tmp3x, .lea(.tmp2x), ._ },
                        .{ ._, .v_q, .mov, .tmp2q, .tmp3x, ._, ._ },
                        .{ ._, .vp_q, .extr, .tmp4q, .tmp3x, .ui(1), ._ },
                        .{ ._, ._rd, .sh, .tmp2q, .tmp4q, .uia(128, .dst0, .sub_bit_size), ._ },
                        .{ ._, ._, .mov, .dst0q, .tmp2q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp4q, .uia(128, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp4q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .ssse3, .gfni, null },
                    .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .xword } } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ },
                        .{ ._, ._b, .gf2p8affineq, .src0x, .lea(.tmp2x), .ui(0), ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_b, .shuf, .src0x, .lea(.tmp2x), ._, ._ },
                        .{ ._, ._q, .mov, .tmp2q, .src0x, ._, ._ },
                        .{ ._, .p_q, .extr, .tmp3q, .src0x, .ui(1), ._ },
                        .{ ._, ._rd, .sh, .tmp2q, .tmp3q, .uia(128, .dst0, .sub_bit_size), ._ },
                        .{ ._, ._, .mov, .dst0q, .tmp2q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp3q, .uia(128, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp3q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, .gfni, null, null },
                    .src_constraints = .{ .{ .exact_int = 256 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_32_u8, .kind = .{ .bits_mem = .forward } },
                        .{ .type = .vector_32_u8, .kind = .{ .pshufb_bswap_mem = .{ .repeat = 2, .size = .xword } } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ },
                        .{ ._, .v_b, .gf2p8affineq, .dst0y, .src0y, .lea(.tmp2y), .ui(0) },
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_b, .shuf, .dst0y, .dst0y, .lea(.tmp2y), ._ },
                        .{ ._, .v_q, .perm, .dst0y, .dst0y, .ui(0b01_00_11_10), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, .gfni, null, null },
                    .src_constraints = .{ .{ .exact_int = 256 }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_32_u8, .kind = .{ .bits_mem = .forward } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .xword } } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ },
                        .{ ._, .v_b, .gf2p8affineq, .dst0y, .src0y, .lea(.tmp2y), .ui(0) },
                        .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp4x, .lea(.tmp2x), ._, ._ },
                        .{ ._, .vp_b, .shuf, .dst0x, .dst0x, .tmp4x, ._ },
                        .{ ._, .vp_b, .shuf, .tmp3x, .tmp3x, .tmp4x, ._ },
                        .{ ._, .v_f128, .insert, .dst0y, .tmp3y, .dst0x, .ui(1) },
                    } },
                }, .{
                    .required_features = .{ .avx2, .gfni, null, null },
                    .src_constraints = .{ .{ .exact_remainder_int = .{ .of = .yword, .is = 256 } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_32_u8, .kind = .{ .bits_mem = .forward } },
                        .{ .type = .vector_32_u8, .kind = .{ .pshufb_bswap_mem = .{ .repeat = 2, .size = .xword } } },
                        .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp4y, .lea(.tmp0y), ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp5y, .lea(.tmp0y), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-32, .dst0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ .@"0:", .v_q, .perm, .tmp6y, .lea(.tmp1y), .ui(0b01_00_11_10), ._ },
                        .{ ._, .v_b, .gf2p8affineq, .tmp6y, .tmp6y, .tmp4y, .ui(0) },
                        .{ ._, .vp_b, .shuf, .tmp6y, .tmp6y, .tmp5y, ._ },
                        .{ ._, .v_dqu, .mov, .memi(.dst0y, .tmp0), .tmp6y, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 32), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, .gfni, null, null },
                    .src_constraints = .{ .{ .exact_remainder_int = .{ .of = .xword, .is = 128 } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .xword } } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp4x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp5x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp6x, .lea(.tmp1x), ._, ._ },
                        .{ ._, .v_b, .gf2p8affineq, .tmp6x, .tmp6x, .tmp4x, .ui(0) },
                        .{ ._, .vp_b, .shuf, .tmp6x, .tmp6x, .tmp5x, ._ },
                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp6x, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .movbe, null, null },
                    .src_constraints = .{ .{ .exact_remainder_int = .{ .of = .xword, .is = 128 } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .uia(0b00001111000011110000111100001111, .none, .repeat), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .uia(0b00110011001100110011001100110011, .none, .repeat), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .uia(0b01010101010101010101010101010101, .none, .repeat), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .lea(.tmp1q), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp5q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp2q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp5q, .ui(4), ._, ._ },
                        .{ ._, ._l, .sh, .tmp6q, .ui(4), ._, ._ },
                        .{ ._, ._, .@"and", .tmp5q, .tmp2q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp5q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp5q, .ui(2), ._, ._ },
                        .{ ._, ._l, .sh, .tmp6q, .ui(2), ._, ._ },
                        .{ ._, ._, .@"and", .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp5q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp4q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp5q, .ui(1), ._, ._ },
                        .{ ._, ._l, .sh, .tmp6q, .ui(1), ._, ._ },
                        .{ ._, ._, .@"and", .tmp5q, .tmp4q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ },
                        .{ ._, ._be, .mov, .memi(.dst0q, .tmp0), .tmp5q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .exact_remainder_int = .{ .of = .xword, .is = 128 } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .uia(0b00001111000011110000111100001111, .none, .repeat), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .uia(0b00110011001100110011001100110011, .none, .repeat), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .uia(0b01010101010101010101010101010101, .none, .repeat), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .lea(.tmp1q), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp5q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp2q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp5q, .ui(4), ._, ._ },
                        .{ ._, ._l, .sh, .tmp6q, .ui(4), ._, ._ },
                        .{ ._, ._, .@"and", .tmp5q, .tmp2q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp5q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp5q, .ui(2), ._, ._ },
                        .{ ._, ._l, .sh, .tmp6q, .ui(2), ._, ._ },
                        .{ ._, ._, .@"and", .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp5q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp4q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp5q, .ui(1), ._, ._ },
                        .{ ._, ._l, .sh, .tmp6q, .ui(1), ._, ._ },
                        .{ ._, ._, .@"and", .tmp5q, .tmp4q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ },
                        .{ ._, .b_, .swap, .tmp5q, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp5q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .movbe, null, null },
                    .src_constraints = .{ .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 64 } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .mem(.src0d), ._, ._ },
                        .{ ._, ._l, .sa, .tmp2q, .ui(63), ._, ._ },
                        .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp2q, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .uia(0b00001111000011110000111100001111, .none, .repeat), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .uia(0b00110011001100110011001100110011, .none, .repeat), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .uia(0b01010101010101010101010101010101, .none, .repeat), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .lea(.tmp1q), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp5q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp2q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp5q, .ui(4), ._, ._ },
                        .{ ._, ._l, .sh, .tmp6q, .ui(4), ._, ._ },
                        .{ ._, ._, .@"and", .tmp5q, .tmp2q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp5q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp5q, .ui(2), ._, ._ },
                        .{ ._, ._l, .sh, .tmp6q, .ui(2), ._, ._ },
                        .{ ._, ._, .@"and", .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp5q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp4q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp5q, .ui(1), ._, ._ },
                        .{ ._, ._l, .sh, .tmp6q, .ui(1), ._, ._ },
                        .{ ._, ._, .@"and", .tmp5q, .tmp4q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ },
                        .{ ._, ._be, .mov, .memi(.dst0q, .tmp0), .tmp5q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 64 } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .mem(.src0d), ._, ._ },
                        .{ ._, ._l, .sa, .tmp2q, .ui(63), ._, ._ },
                        .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp2q, ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .uia(0b00001111000011110000111100001111, .none, .repeat), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .uia(0b00110011001100110011001100110011, .none, .repeat), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .uia(0b01010101010101010101010101010101, .none, .repeat), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .lea(.tmp1q), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp5q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp2q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp5q, .ui(4), ._, ._ },
                        .{ ._, ._l, .sh, .tmp6q, .ui(4), ._, ._ },
                        .{ ._, ._, .@"and", .tmp5q, .tmp2q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp5q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp5q, .ui(2), ._, ._ },
                        .{ ._, ._l, .sh, .tmp6q, .ui(2), ._, ._ },
                        .{ ._, ._, .@"and", .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp5q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp4q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp5q, .ui(1), ._, ._ },
                        .{ ._, ._l, .sh, .tmp6q, .ui(1), ._, ._ },
                        .{ ._, ._, .@"and", .tmp5q, .tmp4q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ },
                        .{ ._, .b_, .swap, .tmp5q, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp5q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .movbe, null, null },
                    .src_constraints = .{ .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .uia(0b00001111000011110000111100001111, .none, .repeat), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .uia(0b00110011001100110011001100110011, .none, .repeat), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .uia(0b01010101010101010101010101010101, .none, .repeat), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .lea(.tmp1q), ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp5q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp2q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp5q, .ui(4), ._, ._ },
                        .{ ._, ._l, .sh, .tmp6q, .ui(4), ._, ._ },
                        .{ ._, ._, .@"and", .tmp5q, .tmp2q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp5q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp5q, .ui(2), ._, ._ },
                        .{ ._, ._l, .sh, .tmp6q, .ui(2), ._, ._ },
                        .{ ._, ._, .@"and", .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp5q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp4q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp5q, .ui(1), ._, ._ },
                        .{ ._, ._l, .sh, .tmp6q, .ui(1), ._, ._ },
                        .{ ._, ._, .@"and", .tmp5q, .tmp4q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ },
                        .{ ._, ._be, .mov, .memi(.dst0q, .tmp0), .tmp5q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .uia(0b00001111000011110000111100001111, .none, .repeat), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .uia(0b00110011001100110011001100110011, .none, .repeat), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .uia(0b01010101010101010101010101010101, .none, .repeat), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp5q, .lea(.tmp1q), ._, ._ },
                        .{ ._, .b_, .swap, .tmp5q, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp5q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp2q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp5q, .ui(4), ._, ._ },
                        .{ ._, ._l, .sh, .tmp6q, .ui(4), ._, ._ },
                        .{ ._, ._, .@"and", .tmp5q, .tmp2q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp5q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp5q, .ui(2), ._, ._ },
                        .{ ._, ._l, .sh, .tmp6q, .ui(2), ._, ._ },
                        .{ ._, ._, .@"and", .tmp5q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .tmp6q, .tmp5q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp4q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp5q, .ui(1), ._, ._ },
                        .{ ._, ._l, .sh, .tmp6q, .ui(1), ._, ._ },
                        .{ ._, ._, .@"and", .tmp5q, .tmp4q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp5q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .movbe, null, null },
                    .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .mem(.src0d), ._, ._ },
                        .{ ._, ._l, .sa, .tmp2q, .ui(63), ._, ._ },
                        .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp2q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .uia(0b00001111000011110000111100001111, .none, .repeat), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .uia(0b00110011001100110011001100110011, .none, .repeat), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .uia(0b01010101010101010101010101010101, .none, .repeat), ._, ._ },
                        .{ .@"0:", ._be, .mov, .tmp6q, .lea(.tmp1q), ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp6q, .ui(4), ._, ._ },
                        .{ ._, ._l, .sh, .tmp7q, .ui(4), ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp7q, .tmp4q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp6q, .ui(2), ._, ._ },
                        .{ ._, ._l, .sh, .tmp7q, .ui(2), ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp4q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp7q, .tmp5q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp6q, .ui(1), ._, ._ },
                        .{ ._, ._l, .sh, .tmp7q, .ui(1), ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp5q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._rd, .sh, .tmp6q, .tmp2q, .uia(64, .src0, .sub_bit_size_rem_64), ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp7q, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .mem(.src0d), ._, ._ },
                        .{ ._, ._l, .sa, .tmp2q, .ui(63), ._, ._ },
                        .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp2q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .uia(0b00001111000011110000111100001111, .none, .repeat), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .uia(0b00110011001100110011001100110011, .none, .repeat), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .uia(0b01010101010101010101010101010101, .none, .repeat), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp6q, .lea(.tmp1q), ._, ._ },
                        .{ ._, .b_, .swap, .tmp6q, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp6q, .ui(4), ._, ._ },
                        .{ ._, ._l, .sh, .tmp7q, .ui(4), ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp7q, .tmp4q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp6q, .ui(2), ._, ._ },
                        .{ ._, ._l, .sh, .tmp7q, .ui(2), ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp4q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp7q, .tmp5q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp6q, .ui(1), ._, ._ },
                        .{ ._, ._l, .sh, .tmp7q, .ui(1), ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp5q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._rd, .sh, .tmp6q, .tmp2q, .uia(64, .src0, .sub_bit_size_rem_64), ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp7q, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .movbe, null, null },
                    .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp2q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .uia(0b00001111000011110000111100001111, .none, .repeat), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .uia(0b00110011001100110011001100110011, .none, .repeat), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .uia(0b01010101010101010101010101010101, .none, .repeat), ._, ._ },
                        .{ .@"0:", ._be, .mov, .tmp6q, .lea(.tmp1q), ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp6q, .ui(4), ._, ._ },
                        .{ ._, ._l, .sh, .tmp7q, .ui(4), ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp7q, .tmp4q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp6q, .ui(2), ._, ._ },
                        .{ ._, ._l, .sh, .tmp7q, .ui(2), ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp4q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp7q, .tmp5q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp6q, .ui(1), ._, ._ },
                        .{ ._, ._l, .sh, .tmp7q, .ui(1), ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp5q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._rd, .sh, .tmp6q, .tmp2q, .uia(64, .src0, .sub_bit_size_rem_64), ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp7q, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp2q, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .uia(0b00001111000011110000111100001111, .none, .repeat), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .uia(0b00110011001100110011001100110011, .none, .repeat), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .uia(0b01010101010101010101010101010101, .none, .repeat), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp6q, .lea(.tmp1q), ._, ._ },
                        .{ ._, .b_, .swap, .tmp6q, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp6q, .ui(4), ._, ._ },
                        .{ ._, ._l, .sh, .tmp7q, .ui(4), ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp7q, .tmp4q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp6q, .ui(2), ._, ._ },
                        .{ ._, ._l, .sh, .tmp7q, .ui(2), ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp4q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp7q, .tmp5q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp6q, .ui(1), ._, ._ },
                        .{ ._, ._l, .sh, .tmp7q, .ui(1), ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp5q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._rd, .sh, .tmp6q, .tmp2q, .uia(64, .src0, .sub_bit_size_rem_64), ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp7q, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .movbe, null, null },
                    .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .mem(.src0d), ._, ._ },
                        .{ ._, ._l, .sa, .tmp2q, .ui(63), ._, ._ },
                        .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .uia(0b00001111000011110000111100001111, .none, .repeat), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .uia(0b00110011001100110011001100110011, .none, .repeat), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .uia(0b01010101010101010101010101010101, .none, .repeat), ._, ._ },
                        .{ .@"0:", ._be, .mov, .tmp6q, .lea(.tmp1q), ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp6q, .ui(4), ._, ._ },
                        .{ ._, ._l, .sh, .tmp7q, .ui(4), ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp7q, .tmp4q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp6q, .ui(2), ._, ._ },
                        .{ ._, ._l, .sh, .tmp7q, .ui(2), ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp4q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp7q, .tmp5q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp6q, .ui(1), ._, ._ },
                        .{ ._, ._l, .sh, .tmp7q, .ui(1), ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp5q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._rd, .sh, .tmp6q, .tmp2q, .uia(64, .src0, .sub_bit_size_rem_64), ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp7q, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .mem(.src0d), ._, ._ },
                        .{ ._, ._l, .sa, .tmp2q, .ui(63), ._, ._ },
                        .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .uia(0b00001111000011110000111100001111, .none, .repeat), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .uia(0b00110011001100110011001100110011, .none, .repeat), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .uia(0b01010101010101010101010101010101, .none, .repeat), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp6q, .lea(.tmp1q), ._, ._ },
                        .{ ._, .b_, .swap, .tmp6q, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp6q, .ui(4), ._, ._ },
                        .{ ._, ._l, .sh, .tmp7q, .ui(4), ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp7q, .tmp4q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp6q, .ui(2), ._, ._ },
                        .{ ._, ._l, .sh, .tmp7q, .ui(2), ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp4q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp7q, .tmp5q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp6q, .ui(1), ._, ._ },
                        .{ ._, ._l, .sh, .tmp7q, .ui(1), ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp5q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._rd, .sh, .tmp6q, .tmp2q, .uia(64, .src0, .sub_bit_size_rem_64), ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp7q, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .movbe, null, null },
                    .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .uia(0b00001111000011110000111100001111, .none, .repeat), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .uia(0b00110011001100110011001100110011, .none, .repeat), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .uia(0b01010101010101010101010101010101, .none, .repeat), ._, ._ },
                        .{ .@"0:", ._be, .mov, .tmp6q, .lea(.tmp1q), ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp6q, .ui(4), ._, ._ },
                        .{ ._, ._l, .sh, .tmp7q, .ui(4), ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp7q, .tmp4q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp6q, .ui(2), ._, ._ },
                        .{ ._, ._l, .sh, .tmp7q, .ui(2), ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp4q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp7q, .tmp5q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp6q, .ui(1), ._, ._ },
                        .{ ._, ._l, .sh, .tmp7q, .ui(1), ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp5q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._rd, .sh, .tmp6q, .tmp2q, .uia(64, .src0, .sub_bit_size_rem_64), ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp7q, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .uia(0b00001111000011110000111100001111, .none, .repeat), ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .uia(0b00110011001100110011001100110011, .none, .repeat), ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .uia(0b01010101010101010101010101010101, .none, .repeat), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp6q, .lea(.tmp1q), ._, ._ },
                        .{ ._, .b_, .swap, .tmp6q, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp7q, .tmp3q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp6q, .ui(4), ._, ._ },
                        .{ ._, ._l, .sh, .tmp7q, .ui(4), ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp3q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp7q, .tmp4q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp6q, .ui(2), ._, ._ },
                        .{ ._, ._l, .sh, .tmp7q, .ui(2), ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp4q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._, .@"and", .tmp7q, .tmp5q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp6q, .ui(1), ._, ._ },
                        .{ ._, ._l, .sh, .tmp7q, .ui(1), ._, ._ },
                        .{ ._, ._, .@"and", .tmp6q, .tmp5q, ._, ._ },
                        .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ },
                        .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ },
                        .{ ._, ._rd, .sh, .tmp6q, .tmp2q, .uia(64, .src0, .sub_bit_size_rem_64), ._ },
                        .{ ._, ._, .mov, .tmp2q, .tmp7q, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp6q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f}", .{
                        @tagName(air_tag),
                        ty_op.ty.toType().fmt(pt),
                        ops[0].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{ty_op.operand}, &ops, cg);
            },
            .sqrt => |air_tag| {
                const un_op = air_datas[@intFromEnum(inst)].un_op;
                var ops = try cg.tempsFromOperands(inst, .{un_op});
                var res: [1]Temp = undefined;
                cg.select(&res, &.{cg.typeOf(un_op)}, &ops, comptime &.{ .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                        .{ ._, .v_ss, .sqrt, .dst0x, .dst0x, .dst0d, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__sqrth" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .word } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                        .{ ._, .v_ps, .sqrt, .dst0x, .dst0x, ._, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .word } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
                        .{ ._, .v_ps, .sqrt, .dst0y, .dst0y, ._, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_ps, .sqrt, .tmp1y, .tmp1y, ._, ._ },
                        .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__sqrth" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__sqrth" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__sqrth" } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .tmp3d, .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__sqrth" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ },
                        .{ ._, .v_ss, .sqrt, .dst0x, .dst0x, .src0d, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ss, .sqrt, .dst0x, .src0x, .src0d, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ },
                        .{ ._, ._ss, .sqrt, .dst0x, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._ss, .sqrt, .dst0x, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "sqrtf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .sqrt, .dst0x, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._ps, .sqrt, .dst0x, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .sqrt, .dst0y, .src0y, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_ps, .sqrt, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .sqrt, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "sqrtf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "sqrtf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ },
                        .{ ._, .v_sd, .sqrt, .dst0x, .dst0x, .src0q, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_sd, .sqrt, .dst0x, .src0x, .src0q, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ },
                        .{ ._, ._sd, .sqrt, .dst0x, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._sd, .sqrt, .dst0x, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "sqrt" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_pd, .sqrt, .dst0x, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._pd, .sqrt, .dst0x, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_pd, .sqrt, .dst0y, .src0y, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_pd, .sqrt, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._pd, .sqrt, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "sqrt" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "sqrt" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "sqrt" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_x87, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .x87 } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .f_, .sqrt, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .msvc,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_x87, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .x87 } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_00_11), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
                        .{ ._, .f_, .sqrt, ._, ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, .f_, .sqrt, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .msvc,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .fn_cw, .st, .tmp0w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp1d, .memd(.tmp0b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp0b, 1), .ui(0b000_0_00_11), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp0b, 1), .tmp1b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp1, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, .f_, .sqrt, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .memia(.dst0t, .tmp1, .add_unaligned_size), ._, ._, ._ },
                        .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "sqrtq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "sqrtq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "sqrtq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "sqrtq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "sqrtq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "sqrtq" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "sqrtq" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "sqrtq" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f}", .{
                        @tagName(air_tag),
                        cg.typeOf(un_op).fmt(pt),
                        ops[0].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{un_op}, &ops, cg);
            },
            .sin, .cos, .tan, .exp, .exp2, .log, .log2, .log10, .round => |air_tag| {
                const un_op = air_datas[@intFromEnum(inst)].un_op;
                var ops = try cg.tempsFromOperands(inst, .{un_op});
                var res: [1]Temp = undefined;
                cg.select(&res, &.{cg.typeOf(un_op)}, &ops, switch (air_tag) {
                    else => unreachable,
                    inline .sin, .cos, .tan, .exp, .exp2, .log, .log2, .log10, .round => |name| comptime &.{ .{
                        .required_features = .{ .sse, null, null, null },
                        .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .extern_func = "__" ++ @tagName(name) ++ "h" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__" ++ @tagName(name) ++ "h" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                            .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
                            .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp1x, .ui(0), ._ },
                            .{ ._, ._, .sub, .tmp0p, .si(2), ._, ._ },
                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__" ++ @tagName(name) ++ "h" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                            .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp1x, .ui(0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__" ++ @tagName(name) ++ "h" } },
                            .{ .type = .f16, .kind = .{ .reg = .ax } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                            .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, .p_w, .extr, .tmp3d, .tmp1x, .ui(0), ._ },
                            .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f16, .kind = .{ .reg = .ax } },
                            .{ .type = .f32, .kind = .mem },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__" ++ @tagName(name) ++ "h" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                            .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                            .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                            .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
                            .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                            .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ },
                            .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ },
                            .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .extern_func = @tagName(name) ++ "f" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = @tagName(name) ++ "f" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                            .{ .@"0:", .v_ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp0), .tmp1x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = @tagName(name) ++ "f" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                            .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp1x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .extern_func = @tagName(name) } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = @tagName(name) } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                            .{ .@"0:", .v_sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, .v_sd, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = @tagName(name) } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                            .{ .@"0:", ._sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._sd, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = @tagName(name) } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                            .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .movl, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._ps, .movl, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .avx, .x87, null, null },
                        .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .size = 16, .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__" ++ @tagName(name) ++ "x" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .reg = .st0 }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, .v_dqa, .mov, .tmp0x, .mem(.src0x), ._, ._ },
                            .{ ._, .v_dqa, .mov, .mem(.tmp1x), .tmp0x, ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .sse2, .x87, null, null },
                        .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .size = 16, .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__" ++ @tagName(name) ++ "x" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .reg = .st0 }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._dqa, .mov, .tmp0x, .mem(.src0x), ._, ._ },
                            .{ ._, ._dqa, .mov, .mem(.tmp1x), .tmp0x, ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .sse, .x87, null, null },
                        .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .size = 16, .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__" ++ @tagName(name) ++ "x" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .reg = .st0 }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .mova, .tmp0x, .mem(.src0x), ._, ._ },
                            .{ ._, ._ps, .mova, .mem(.tmp1x), .tmp0x, ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__" ++ @tagName(name) ++ "x" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .avx, .x87, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .size = 16, .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__" ++ @tagName(name) ++ "x" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .v_dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                            .{ ._, .f_p, .st, .memi(.dst0t, .tmp0), ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .sse2, .x87, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .size = 16, .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__" ++ @tagName(name) ++ "x" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                            .{ ._, .f_p, .st, .memi(.dst0t, .tmp0), ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .sse, .x87, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .size = 16, .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__" ++ @tagName(name) ++ "x" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._ps, .mova, .mem(.tmp2x), .tmp1x, ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                            .{ ._, .f_p, .st, .memi(.dst0t, .tmp0), ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__" ++ @tagName(name) ++ "x" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp1p, .memi(.dst0, .tmp0), ._, ._ },
                            .{ ._, ._, .lea, .tmp2p, .memi(.src0, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .sse, null, null, null },
                        .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .extern_func = @tagName(name) ++ "q" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .required_features = .{ .sse, null, null, null },
                        .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = @tagName(name) ++ "q" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                            .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .avx, null, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = @tagName(name) ++ "q" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .sse2, null, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = @tagName(name) ++ "q" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .sse, null, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = @tagName(name) ++ "q" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .required_features = .{ .avx, null, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = @tagName(name) ++ "q" } },
                            .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .required_features = .{ .sse2, null, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = @tagName(name) ++ "q" } },
                            .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .required_features = .{ .sse, null, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = @tagName(name) ++ "q" } },
                            .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        } },
                    } },
                }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f}", .{
                        @tagName(air_tag),
                        cg.typeOf(un_op).fmt(pt),
                        ops[0].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{un_op}, &ops, cg);
            },
            .abs => |air_tag| {
                const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                var res: [1]Temp = undefined;
                cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                        .{ ._, ._, .sub, .dst0b, .src0b, ._, ._ },
                        .{ ._, ._s, .cmov, .dst0d, .src0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0b, .si(0), ._, ._ },
                        .{ ._, ._ge, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .neg, .dst0b, ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .@"test", .src0b, .src0b, ._, ._ },
                        .{ ._, ._ns, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .neg, .dst0b, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .int = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                        .{ ._, ._, .sub, .dst0w, .src0w, ._, ._ },
                        .{ ._, ._s, .cmov, .dst0w, .src0w, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .int = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                        .{ ._, ._, .sub, .dst0w, .src0w, ._, ._ },
                        .{ ._, ._s, .cmov, .dst0d, .src0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .int = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0w, .si(0), ._, ._ },
                        .{ ._, ._ge, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .neg, .dst0d, ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .int = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .@"test", .src0w, .src0w, ._, ._ },
                        .{ ._, ._ns, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .neg, .dst0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                        .{ ._, ._, .sub, .dst0d, .src0d, ._, ._ },
                        .{ ._, ._s, .cmov, .dst0d, .src0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0d, .si(0), ._, ._ },
                        .{ ._, ._ge, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .neg, .dst0d, ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .@"test", .src0d, .src0d, ._, ._ },
                        .{ ._, ._ns, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .neg, .dst0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{ .{ .int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                        .{ ._, ._, .sub, .dst0q, .src0q, ._, ._ },
                        .{ ._, ._s, .cmov, .dst0q, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0q, .si(0), ._, ._ },
                        .{ ._, ._ge, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .neg, .dst0q, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .@"test", .src0q, .src0q, ._, ._ },
                        .{ ._, ._ns, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .neg, .dst0q, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .any_int, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp3q, .memia(.src0q, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp3q, .tmp1q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp2b, .ui(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp3q, .tmp1q, ._, ._ },
                        .{ ._, ._c, .set, .tmp2b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp3q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .mmx, .ssse3, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_mmx, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .mmx } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_b, .abs, .dst0q, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .mmx, .ssse3, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .word } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_mmx, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .mmx } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_w, .abs, .dst0q, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .mmx, .ssse3, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .dword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_mmx, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .mmx } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_d, .abs, .dst0q, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .ssse3, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_b, .abs, .dst0x, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .ssse3, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_w, .abs, .dst0x, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .ssse3, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_d, .abs, .dst0x, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_b, .abs, .dst0x, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .abs, .dst0x, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .abs, .dst0x, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_b, .abs, .dst0y, .src0y, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .abs, .dst0y, .src0y, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .abs, .dst0y, .src0y, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .vp_b, .abs, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .vp_w, .abs, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .vp_d, .abs, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .vp_b, .abs, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .vp_w, .abs, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .vp_d, .abs, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .ssse3, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .p_b, .abs, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .ssse3, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .p_w, .abs, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .ssse3, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .p_d, .abs, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .mmx, .ssse3, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .p_b, .abs, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .mmx, .ssse3, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .word } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .p_w, .abs, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .mmx, .ssse3, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .dword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .p_d, .abs, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._, .movsx, .tmp2d, .memia(.src0b, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1b, .tmp2b, ._, ._ },
                        .{ ._, ._s, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._, .movsx, .tmp2d, .memia(.src0b, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1b, .tmp2b, ._, ._ },
                        .{ ._, ._s, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._ns, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .neg, .tmp1b, ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ },
                        .{ ._, ._ns, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .neg, .tmp1b, ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._, .sub, .tmp1w, .memia(.src0w, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._s, .cmov, .tmp1w, .memia(.src0w, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._ns, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .neg, .tmp1d, ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .memia(.src0d, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._s, .cmov, .tmp1d, .memia(.src0d, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._ns, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .neg, .tmp1d, ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0d, .tmp0, .add_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._, .sub, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._s, .cmov, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .@"test", .tmp1q, .tmp1q, ._, ._ },
                        .{ ._, ._ns, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .neg, .tmp1q, ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .any_scalar_int, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .sa(.none, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_src0_elem_size, -8), ._, ._ },
                        .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ .@"1:", ._, .mov, .tmp4q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .xor, .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._r, .sh, .tmp3b, .ui(1), ._, ._ },
                        .{ ._, ._, .sbb, .tmp4q, .tmp2q, ._, ._ },
                        .{ ._, ._c, .set, .tmp3b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._, .lea, .tmp0d, .lead(.tmp0, 8), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(8), ._, ._ },
                        .{ ._, ._a, .j, .@"1b", ._, ._, ._ },
                        .{ ._, ._, .cmp, .tmp0d, .sa(.src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._b, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_ps, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._ps, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_ps, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_pd, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._pd, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_pd, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_x87, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .x87 } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .f_, .abs, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_any_float = .xword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_any_float = .xword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .scalar_any_float = .xword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._ps, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_any_float = .yword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_any_float = .yword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_pd, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } },
                        .{ .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_ps, .mova, .tmp2y, .lea(.tmp0y), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_ps, .@"and", .tmp3y, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._ },
                        .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_size), .tmp3y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._ps, .mova, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, ._ps, .@"and", .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } },
                        .{ .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_pd, .mova, .tmp2y, .lea(.tmp0y), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_pd, .@"and", .tmp3y, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._ },
                        .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_size), .tmp3y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._pd, .mova, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._pd, .mova, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, ._pd, .@"and", .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_any_float = .yword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } },
                        .{ .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp2y, .lea(.tmp0y), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .vp_, .@"and", .tmp3y, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp3y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_any_float = .yword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } },
                        .{ .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_pd, .mova, .tmp2y, .lea(.tmp0y), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_pd, .@"and", .tmp3y, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._ },
                        .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_size), .tmp3y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_any_float = .xword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, .p_, .@"and", .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_any_float = .xword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._ps, .mova, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, ._ps, .@"and", .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f}", .{
                        @tagName(air_tag),
                        cg.typeOf(ty_op.operand).fmt(pt),
                        ops[0].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{ty_op.operand}, &ops, cg);
            },
            .floor, .ceil, .trunc_float => |air_tag| {
                const un_op = air_datas[@intFromEnum(inst)].un_op;
                var ops = try cg.tempsFromOperands(inst, .{un_op});
                var res: [1]Temp = undefined;
                cg.select(&res, &.{cg.typeOf(un_op)}, &ops, switch (@as(bits.RoundMode.Direction, switch (air_tag) {
                    else => unreachable,
                    .floor => .down,
                    .ceil => .up,
                    .trunc_float => .zero,
                })) {
                    else => unreachable,
                    inline .down, .up, .zero => |direction| comptime &.{ .{
                        .required_features = .{ .f16c, null, null, null },
                        .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                            .{ ._, .v_ss, .round, .dst0x, .dst0x, .dst0d, .rm(.{ .direction = direction, .precision = .inexact }) },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .down => "__floorh",
                                .up => "__ceilh",
                                .zero => "__trunch",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                            .{ ._, .v_ps, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
                            .{ ._, .v_ps, .round, .dst0y, .dst0y, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                            .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_ps, .round, .tmp1y, .tmp1y, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
                            .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ },
                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .down => "__floorh",
                                .up => "__ceilh",
                                .zero => "__trunch",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                            .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
                            .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
                            .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .down => "__floorh",
                                .up => "__ceilh",
                                .zero => "__trunch",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                            .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
                            .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .down => "__floorh",
                                .up => "__ceilh",
                                .zero => "__trunch",
                            } } },
                            .{ .type = .f16, .kind = .{ .reg = .ax } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                            .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, .p_w, .extr, .tmp3d, .tmp1x, .ui(0), ._ },
                            .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f16, .kind = .{ .reg = .ax } },
                            .{ .type = .f32, .kind = .mem },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .down => "__floorh",
                                .up => "__ceilh",
                                .zero => "__trunch",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                            .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                            .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
                            .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                            .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ },
                            .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ },
                            .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ss, .round, .dst0x, .dst0x, .src0d, .rm(.{ .direction = direction, .precision = .inexact }) },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ss, .round, .dst0x, .src0x, .src0d, .rm(.{ .direction = direction, .precision = .inexact }) },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ },
                            .{ ._, ._ss, .round, .dst0x, .src0d, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ss, .round, .dst0x, .src0d, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .down => "floorf",
                                .up => "ceilf",
                                .zero => "truncf",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .round, .dst0x, .src0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .round, .dst0x, .src0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .src_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .round, .dst0y, .src0y, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                            .{ .@"0:", .v_ps, .round, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), .rm(.{
                                .direction = direction,
                                .precision = .inexact,
                            }), ._ },
                            .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                            .{ .@"0:", ._ps, .round, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), .rm(.{
                                .direction = direction,
                                .precision = .inexact,
                            }), ._ },
                            .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .down => "floorf",
                                .up => "ceilf",
                                .zero => "truncf",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                            .{ .@"0:", .v_ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .down => "floorf",
                                .up => "ceilf",
                                .zero => "truncf",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                            .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_sd, .round, .dst0x, .dst0x, .src0q, .rm(.{ .direction = direction, .precision = .inexact }) },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_sd, .round, .dst0x, .src0x, .src0q, .rm(.{ .direction = direction, .precision = .inexact }) },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ },
                            .{ ._, ._sd, .round, .dst0x, .src0q, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._sd, .round, .dst0x, .src0q, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .down => "floor",
                                .up => "ceil",
                                .zero => "trunc",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_pd, .round, .dst0x, .src0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._pd, .round, .dst0x, .src0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .src_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_pd, .round, .dst0y, .src0y, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                            .{ .@"0:", .v_pd, .round, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), .rm(.{
                                .direction = direction,
                                .precision = .inexact,
                            }), ._ },
                            .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                            .{ .@"0:", ._pd, .round, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), .rm(.{
                                .direction = direction,
                                .precision = .inexact,
                            }), ._ },
                            .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .down => "floor",
                                .up => "ceil",
                                .zero => "trunc",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                            .{ .@"0:", .v_sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, .v_sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .down => "floor",
                                .up => "ceil",
                                .zero => "trunc",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                            .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .down => "floor",
                                .up => "ceil",
                                .zero => "trunc",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                            .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .avx, .x87, null, null },
                        .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .size = 16, .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .down => "__floorx",
                                .up => "__ceilx",
                                .zero => "__truncx",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .reg = .st0 }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, .v_dqa, .mov, .tmp0x, .mem(.src0x), ._, ._ },
                            .{ ._, .v_dqa, .mov, .mem(.tmp1x), .tmp0x, ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .sse2, .x87, null, null },
                        .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .size = 16, .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .down => "__floorx",
                                .up => "__ceilx",
                                .zero => "__truncx",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .reg = .st0 }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._dqa, .mov, .tmp0x, .mem(.src0x), ._, ._ },
                            .{ ._, ._dqa, .mov, .mem(.tmp1x), .tmp0x, ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .sse, .x87, null, null },
                        .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .size = 16, .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .down => "__floorx",
                                .up => "__ceilx",
                                .zero => "__truncx",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .reg = .st0 }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .mova, .tmp0x, .mem(.src0x), ._, ._ },
                            .{ ._, ._ps, .mova, .mem(.tmp1x), .tmp0x, ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .down => "__floorx",
                                .up => "__ceilx",
                                .zero => "__truncx",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .avx, .x87, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .size = 16, .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .down => "__floorx",
                                .up => "__ceilx",
                                .zero => "__truncx",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                            .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                            .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .sse2, .x87, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .size = 16, .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .down => "__floorx",
                                .up => "__ceilx",
                                .zero => "__truncx",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                            .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .sse, .x87, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .size = 16, .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .down => "__floorx",
                                .up => "__ceilx",
                                .zero => "__truncx",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                            .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._ps, .mova, .mem(.tmp2x), .tmp1x, ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                            .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .down => "__floorx",
                                .up => "__ceilx",
                                .zero => "__truncx",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp1p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp2p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .sse, null, null, null },
                        .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .down => "floorq",
                                .up => "ceilq",
                                .zero => "truncq",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .required_features = .{ .sse, null, null, null },
                        .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .down => "floorq",
                                .up => "ceilq",
                                .zero => "truncq",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                            .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .avx, null, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .down => "floorq",
                                .up => "ceilq",
                                .zero => "truncq",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .sse2, null, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .down => "floorq",
                                .up => "ceilq",
                                .zero => "truncq",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .sse, null, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .down => "floorq",
                                .up => "ceilq",
                                .zero => "truncq",
                            } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .required_features = .{ .avx, null, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .down => "floorq",
                                .up => "ceilq",
                                .zero => "truncq",
                            } } },
                            .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .required_features = .{ .sse2, null, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .down => "floorq",
                                .up => "ceilq",
                                .zero => "truncq",
                            } } },
                            .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .required_features = .{ .sse, null, null, null },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = switch (direction) {
                                else => unreachable,
                                .down => "floorq",
                                .up => "ceilq",
                                .zero => "truncq",
                            } } },
                            .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        } },
                    } },
                }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f}", .{
                        @tagName(air_tag),
                        cg.typeOf(un_op).fmt(pt),
                        ops[0].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{un_op}, &ops, cg);
            },
            .neg, .neg_optimized => |air_tag| {
                const un_op = air_datas[@intFromEnum(inst)].un_op;
                var ops = try cg.tempsFromOperands(inst, .{un_op});
                var res: [1]Temp = undefined;
                cg.select(&res, &.{cg.typeOf(un_op)}, &ops, comptime &.{ .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_ps, .xor, .dst0x, .src0x, .lea(.tmp0x), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._ps, .xor, .dst0x, .lea(.tmp0x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .yword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_ps, .xor, .dst0y, .src0y, .lea(.tmp0y), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_pd, .xor, .dst0x, .src0x, .lea(.tmp0x), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._pd, .xor, .dst0x, .lea(.tmp0x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .yword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_pd, .xor, .dst0y, .src0y, .lea(.tmp0y), ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_x87, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .x87 } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .f_, .chs, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_any_float = .xword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_, .xor, .dst0x, .src0x, .lea(.tmp0x), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_any_float = .xword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_, .xor, .dst0x, .lea(.tmp0x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .scalar_any_float = .xword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._ps, .xor, .dst0x, .lea(.tmp0x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_any_float = .yword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .yword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_, .xor, .dst0y, .src0y, .lea(.tmp0y), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_any_float = .yword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .yword } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_pd, .xor, .dst0y, .src0y, .lea(.tmp0y), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .yword } } },
                        .{ .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_ps, .mova, .tmp2y, .lea(.tmp0y), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_ps, .xor, .tmp3y, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._ },
                        .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_size), .tmp3y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._ps, .mova, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, ._ps, .xor, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .yword } } },
                        .{ .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_pd, .mova, .tmp2y, .lea(.tmp0y), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_pd, .xor, .tmp3y, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._ },
                        .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_size), .tmp3y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._pd, .mova, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._pd, .mova, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, ._pd, .xor, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_any_float = .yword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .yword } } },
                        .{ .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp2y, .lea(.tmp0y), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp3y, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp3y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_any_float = .yword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .yword } } },
                        .{ .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_pd, .mova, .tmp2y, .lea(.tmp0y), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_pd, .xor, .tmp3y, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._ },
                        .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_size), .tmp3y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_any_float = .xword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_any_float = .xword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } },
                        .{ .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._ps, .mova, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, ._ps, .xor, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f}", .{
                        @tagName(air_tag),
                        cg.typeOf(un_op).fmt(pt),
                        ops[0].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{un_op}, &ops, cg);
            },
            .cmp_lt,
            .cmp_lt_optimized,
            .cmp_lte,
            .cmp_lte_optimized,
            .cmp_gte,
            .cmp_gte_optimized,
            .cmp_gt,
            .cmp_gt_optimized,
            => |air_tag| {
                const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                const cmp_op = air_tag.toCmpOp().?;
                var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                var res: [1]Temp = undefined;
                (if (cg.floatBits(cg.typeOf(bin_op.lhs))) |_| err: {
                    switch (cmp_op) {
                        else => unreachable,
                        .lt, .lte => {},
                        .gt, .gte => std.mem.swap(Temp, &ops[0], &ops[1]),
                    }
                    break :err cg.select(&res, &.{.bool}, &ops, switch (switch (cmp_op) {
                        else => unreachable,
                        .lt, .gt => true,
                        .lte, .gte => false,
                    }) {
                        inline false, true => |strict| comptime &.{ .{
                            .required_features = .{ .f16c, null, null, null },
                            .src_constraints = .{ .{ .float = .word }, .{ .float = .word }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .to_sse, .none }, .commute = .{ 0, 1 } },
                            },
                            .extra_temps = .{
                                .{ .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                                .{ .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .cc = switch (strict) {
                                true => .a,
                                false => .ae,
                            } }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, .v_ps, .cvtph2, .tmp0x, .src0q, ._, ._ },
                                .{ ._, .v_ps, .cvtph2, .tmp1x, .src1q, ._, ._ },
                                .{ ._, .v_ss, .ucomi, .tmp0x, .tmp1d, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse, null, null, null },
                            .src_constraints = .{ .{ .float = .word }, .{ .float = .word }, .any },
                            .patterns = &.{
                                .{ .src = .{
                                    .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                                    .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                                    .none,
                                } },
                            },
                            .call_frame = .{ .alignment = .@"16" },
                            .extra_temps = .{
                                .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .cc = switch (strict) {
                                true => .l,
                                false => .le,
                            } }, .unused },
                            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                            .each = .{ .once = &.{
                                .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                                .{ ._, ._, .@"test", .tmp1d, .tmp1d, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .src_constraints = .{ .{ .float = .dword }, .{ .float = .dword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_sse, .to_sse, .none }, .commute = .{ 0, 1 } },
                            },
                            .dst_temps = .{ .{ .cc = switch (strict) {
                                true => .a,
                                false => .ae,
                            } }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, .v_ss, .ucomi, .src0x, .src1d, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse, null, null, null },
                            .src_constraints = .{ .{ .float = .dword }, .{ .float = .dword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_sse, .to_sse, .none }, .commute = .{ 0, 1 } },
                            },
                            .dst_temps = .{ .{ .cc = switch (strict) {
                                true => .a,
                                false => .ae,
                            } }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._ss, .ucomi, .src0x, .src1d, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_sse, .to_sse, .none }, .commute = .{ 0, 1 } },
                            },
                            .dst_temps = .{ .{ .cc = switch (strict) {
                                true => .a,
                                false => .ae,
                            } }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, .v_sd, .ucomi, .src0x, .src1q, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse2, null, null, null },
                            .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_sse, .to_sse, .none }, .commute = .{ 0, 1 } },
                            },
                            .dst_temps = .{ .{ .cc = switch (strict) {
                                true => .a,
                                false => .ae,
                            } }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._sd, .ucomi, .src0x, .src1q, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .x87, .cmov, null, null },
                            .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none }, .commute = .{ 0, 1 } },
                            },
                            .extra_temps = .{
                                .{ .type = .f64, .kind = .{ .reg = .st6 } },
                                .{ .type = .f64, .kind = .{ .reg = .st7 } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .cc = switch (strict) {
                                true => .a,
                                false => .ae,
                            } }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, .f_, .ld, .src1q, ._, ._, ._ },
                                .{ ._, .f_, .ld, .src0q, ._, ._, ._ },
                                .{ ._, .f_p, .ucomi, .tmp0t, .tmp1t, ._, ._ },
                                .{ ._, .f_p, .st, .tmp1t, ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sahf, .x87, null, null },
                            .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none }, .commute = .{ 0, 1 } },
                            },
                            .extra_temps = .{
                                .{ .type = .f64, .kind = .{ .reg = .st6 } },
                                .{ .type = .f64, .kind = .{ .reg = .st7 } },
                                .{ .type = .u16, .kind = .{ .reg = .ax } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .cc = switch (strict) {
                                true => .a,
                                false => .ae,
                            } }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, .f_, .ld, .src1q, ._, ._, ._ },
                                .{ ._, .f_, .ld, .src0q, ._, ._, ._ },
                                .{ ._, .f_pp, .ucom, ._, ._, ._, ._ },
                                .{ ._, .fn_sw, .st, .tmp2w, ._, ._, ._ },
                                .{ ._, ._, .sahf, ._, ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .x87, null, null, null },
                            .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none }, .commute = .{ 0, 1 } },
                            },
                            .extra_temps = .{
                                .{ .type = .f64, .kind = .{ .reg = .st6 } },
                                .{ .type = .f64, .kind = .{ .reg = .st7 } },
                                .{ .type = .u16, .kind = .{ .reg = .ax } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .cc = switch (strict) {
                                true => .z,
                                false => .nc,
                            } }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, .f_, .ld, .src1q, ._, ._, ._ },
                                .{ ._, .f_, .ld, .src0q, ._, ._, ._ },
                                .{ ._, .f_pp, .ucom, ._, ._, ._, ._ },
                                .{ ._, .fn_sw, .st, .tmp2w, ._, ._, ._ },
                                switch (strict) {
                                    true => .{ ._, ._, .@"test", .tmp2h, .si(0b1_000_001), ._, ._ },
                                    false => .{ ._, ._r, .sh, .tmp2h, .ui(1), ._, ._ },
                                },
                            } },
                        }, .{
                            .required_features = .{ .x87, .cmov, null, null },
                            .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_x87, .to_x87, .none }, .commute = .{ 0, 1 } },
                            },
                            .extra_temps = .{
                                .{ .type = .f80, .kind = .{ .reg = .st7 } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .cc = switch (strict) {
                                true => .a,
                                false => .ae,
                            } }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                                .{ ._, .f_p, .ucomi, .tmp0t, .src1t, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sahf, .x87, null, null },
                            .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte }, .any },
                            .patterns = &.{
                                .{ .src = .{ .mem, .mem, .none }, .commute = .{ 0, 1 } },
                            },
                            .extra_temps = .{
                                .{ .type = .f80, .kind = .{ .reg = .st6 } },
                                .{ .type = .f80, .kind = .{ .reg = .st7 } },
                                .{ .type = .u16, .kind = .{ .reg = .ax } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .cc = switch (strict) {
                                true => .a,
                                false => .ae,
                            } }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
                                .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                                .{ ._, .f_pp, .ucom, ._, ._, ._, ._ },
                                .{ ._, .fn_sw, .st, .tmp2w, ._, ._, ._ },
                                .{ ._, ._, .sahf, ._, ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sahf, .x87, null, null },
                            .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_x87, .to_x87, .none }, .commute = .{ 0, 1 } },
                            },
                            .extra_temps = .{
                                .{ .type = .f80, .kind = .{ .reg = .st6 } },
                                .{ .type = .f80, .kind = .{ .reg = .st7 } },
                                .{ .type = .u16, .kind = .{ .reg = .ax } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .cc = switch (strict) {
                                true => .a,
                                false => .ae,
                            } }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                                .{ ._, .f_p, .ucom, .src1t, ._, ._, ._ },
                                .{ ._, .fn_sw, .st, .tmp2w, ._, ._, ._ },
                                .{ ._, ._, .sahf, ._, ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .x87, null, null, null },
                            .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte }, .any },
                            .patterns = &.{
                                .{ .src = .{ .mem, .mem, .none }, .commute = .{ 0, 1 } },
                            },
                            .extra_temps = .{
                                .{ .type = .f80, .kind = .{ .reg = .st6 } },
                                .{ .type = .f80, .kind = .{ .reg = .st7 } },
                                .{ .type = .u16, .kind = .{ .reg = .ax } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .cc = switch (strict) {
                                true => .z,
                                false => .nc,
                            } }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
                                .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                                .{ ._, .f_pp, .ucom, ._, ._, ._, ._ },
                                .{ ._, .fn_sw, .st, .tmp2w, ._, ._, ._ },
                                switch (strict) {
                                    true => .{ ._, ._, .@"test", .tmp2h, .si(0b1_000_001), ._, ._ },
                                    false => .{ ._, ._r, .sh, .tmp2h, .ui(1), ._, ._ },
                                },
                            } },
                        }, .{
                            .required_features = .{ .x87, null, null, null },
                            .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_x87, .to_x87, .none }, .commute = .{ 0, 1 } },
                            },
                            .extra_temps = .{
                                .{ .type = .f80, .kind = .{ .reg = .st6 } },
                                .{ .type = .f80, .kind = .{ .reg = .st7 } },
                                .{ .type = .u16, .kind = .{ .reg = .ax } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .cc = switch (strict) {
                                true => .z,
                                false => .nc,
                            } }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                                .{ ._, .f_p, .ucom, .src1t, ._, ._, ._ },
                                .{ ._, .fn_sw, .st, .tmp2w, ._, ._, ._ },
                                switch (strict) {
                                    true => .{ ._, ._, .@"test", .tmp2h, .si(0b1_000_001), ._, ._ },
                                    false => .{ ._, ._r, .sh, .tmp2h, .ui(1), ._, ._ },
                                },
                            } },
                        }, .{
                            .required_cc_abi = .sysv64,
                            .required_features = .{ .sse, null, null, null },
                            .src_constraints = .{ .{ .float = .xword }, .{ .float = .xword }, .any },
                            .patterns = &.{
                                .{ .src = .{
                                    .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                                    .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                                    .none,
                                } },
                            },
                            .call_frame = .{ .alignment = .@"16" },
                            .extra_temps = .{
                                .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .cc = switch (strict) {
                                true => .l,
                                false => .le,
                            } }, .unused },
                            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                            .each = .{ .once = &.{
                                .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                                .{ ._, ._, .@"test", .tmp1d, .tmp1d, ._, ._ },
                            } },
                        }, .{
                            .required_cc_abi = .win64,
                            .required_features = .{ .sse, null, null, null },
                            .src_constraints = .{ .{ .float = .xword }, .{ .float = .xword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .call_frame = .{ .alignment = .@"16" },
                            .extra_temps = .{
                                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .cc = switch (strict) {
                                true => .l,
                                false => .le,
                            } }, .unused },
                            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                                .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                                .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                                .{ ._, ._, .@"test", .tmp3d, .tmp3d, ._, ._ },
                            } },
                        } },
                    });
                } else err: {
                    res[0] = ops[0].cmpInts(cmp_op, &ops[1], cg) catch |err| break :err err;
                }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f} {f}", .{
                        @tagName(air_tag),
                        cg.typeOf(bin_op.lhs).fmt(pt),
                        ops[0].tracking(cg),
                        ops[1].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
            },
            .cmp_eq,
            .cmp_eq_optimized,
            .cmp_neq,
            .cmp_neq_optimized,
            => |air_tag| {
                const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                const cmp_op = air_tag.toCmpOp().?;
                var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                const ty = cg.typeOf(bin_op.lhs);
                var res: [1]Temp = undefined;
                const OptInfo = struct {
                    deaths: [2]Air.Inst.Index,
                    res: [1]Temp,
                    state: State,
                    reloc: Mir.Inst.Index,
                };
                var opt_info: ?OptInfo = null;
                (err: switch (@as(enum { float, int }, if (cg.floatBits(ty)) |_|
                    .float
                else if (cg.intInfo(ty)) |_|
                    .int
                else category: {
                    const child_ty = ty.optionalChild(zcu);
                    const has_value_off: u31 = @intCast(child_ty.abiSize(zcu));
                    var has_values: [2]Temp = undefined;
                    opt_info = @as(OptInfo, undefined);
                    for (&has_values, &ops, &opt_info.?.deaths) |*has_value, *op, *death| {
                        has_value.* = try op.read(.bool, .{ .disp = has_value_off }, cg);
                        const child = try op.read(child_ty, .{}, cg);
                        try op.die(cg);
                        op.* = child;
                        death.* = child.index;
                    }
                    cg.select(
                        &opt_info.?.res,
                        &.{.bool},
                        &has_values,
                        switch (Condition.fromCompareOperatorUnsigned(cmp_op)) {
                            else => unreachable,
                            inline .e, .ne => |cc| comptime &.{.{
                                .src_constraints = .{ .{ .size = .byte }, .{ .size = .byte }, .any },
                                .patterns = &.{
                                    .{ .src = .{ .mem, .imm8, .none } },
                                    .{ .src = .{ .imm8, .mem, .none }, .commute = .{ 0, 1 } },
                                    .{ .src = .{ .to_gpr, .imm8, .none } },
                                    .{ .src = .{ .imm8, .to_gpr, .none }, .commute = .{ 0, 1 } },
                                    .{ .src = .{ .mem, .to_gpr, .none } },
                                    .{ .src = .{ .to_gpr, .mem, .none }, .commute = .{ 0, 1 } },
                                    .{ .src = .{ .to_gpr, .to_gpr, .none } },
                                },
                                .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                                    .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ },
                                    .{ ._, .fromCond(cc), .set, .dst0b, ._, ._, ._ },
                                    .{ ._, ._, .@"test", .src0b, .src1b, ._, ._ },
                                } },
                            }},
                        },
                    ) catch |err| switch (err) {
                        error.SelectFailed => unreachable,
                        else => |e| return e,
                    };
                    for (has_values) |has_value| for (opt_info.?.res) |opt_res| {
                        if (has_value.index == opt_res.index) break;
                    } else try has_value.die(cg);
                    opt_info.?.state = cg.initRetroactiveState();
                    opt_info.?.state.next_temp_index = cg.next_temp_index;
                    var state = try cg.saveState();
                    state.next_temp_index = cg.next_temp_index;
                    for (ops) |op| try op.die(cg);
                    try cg.saveRetroactiveState(&opt_info.?.state);
                    opt_info.?.reloc = try cg.asmJccReloc(.z, undefined);
                    try cg.restoreState(state, &.{}, .{
                        .emit_instructions = false,
                        .update_tracking = true,
                        .resurrect = true,
                        .close_scope = true,
                    });
                    break :category if (cg.floatBits(child_ty)) |_| .float else .int;
                })) {
                    .float => {
                        cg.select(&res, &.{.bool}, &ops, switch (switch (air_tag) {
                            else => unreachable,
                            .cmp_eq, .cmp_neq => false,
                            .cmp_eq_optimized, .cmp_neq_optimized => true,
                        }) {
                            inline false, true => |optimized| comptime &.{ .{
                                .required_features = .{ .f16c, null, null, null },
                                .src_constraints = .{ .{ .float = .word }, .{ .float = .word }, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_sse, .to_sse, .none } },
                                },
                                .extra_temps = .{
                                    .{ .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                                    .{ .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .cc = switch (optimized) {
                                    false => .z_and_np,
                                    true => .z,
                                } }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, .v_ps, .cvtph2, .tmp0x, .src0q, ._, ._ },
                                    .{ ._, .v_ps, .cvtph2, .tmp1x, .src1q, ._, ._ },
                                    .{ ._, .v_ss, .ucomi, .tmp0x, .tmp1d, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .sse, null, null, null },
                                .src_constraints = .{ .{ .float = .word }, .{ .float = .word }, .any },
                                .patterns = &.{
                                    .{ .src = .{
                                        .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                                        .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                                        .none,
                                    } },
                                },
                                .call_frame = .{ .alignment = .@"16" },
                                .extra_temps = .{
                                    .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                    .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .cc = .z }, .unused },
                                .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .tmp1d, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .avx, null, null, null },
                                .src_constraints = .{ .{ .float = .dword }, .{ .float = .dword }, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_sse, .mem, .none } },
                                    .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                                    .{ .src = .{ .to_sse, .to_sse, .none } },
                                },
                                .dst_temps = .{ .{ .cc = switch (optimized) {
                                    false => .z_and_np,
                                    true => .z,
                                } }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, .v_ss, .ucomi, .src0x, .src1d, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .sse, null, null, null },
                                .src_constraints = .{ .{ .float = .dword }, .{ .float = .dword }, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_sse, .mem, .none } },
                                    .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                                    .{ .src = .{ .to_sse, .to_sse, .none } },
                                },
                                .dst_temps = .{ .{ .cc = switch (optimized) {
                                    false => .z_and_np,
                                    true => .z,
                                } }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._ss, .ucomi, .src0x, .src1d, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .avx, null, null, null },
                                .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword }, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_sse, .mem, .none } },
                                    .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                                    .{ .src = .{ .to_sse, .to_sse, .none } },
                                },
                                .dst_temps = .{ .{ .cc = switch (optimized) {
                                    false => .z_and_np,
                                    true => .z,
                                } }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, .v_sd, .ucomi, .src0x, .src1q, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .sse2, null, null, null },
                                .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword }, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_sse, .mem, .none } },
                                    .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                                    .{ .src = .{ .to_sse, .to_sse, .none } },
                                },
                                .dst_temps = .{ .{ .cc = switch (optimized) {
                                    false => .z_and_np,
                                    true => .z,
                                } }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._sd, .ucomi, .src0x, .src1q, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .x87, .cmov, null, null },
                                .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword }, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none }, .commute = .{ 0, 1 } },
                                },
                                .extra_temps = .{
                                    .{ .type = .f64, .kind = .{ .reg = .st6 } },
                                    .{ .type = .f64, .kind = .{ .reg = .st7 } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .cc = switch (optimized) {
                                    false => .z_and_np,
                                    true => .z,
                                } }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, .f_, .ld, .src1q, ._, ._, ._ },
                                    .{ ._, .f_, .ld, .src0q, ._, ._, ._ },
                                    .{ ._, .f_p, .ucomi, .tmp0t, .tmp1t, ._, ._ },
                                    .{ ._, .f_p, .st, .tmp1t, ._, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .sahf, .x87, null, null },
                                .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword }, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none }, .commute = .{ 0, 1 } },
                                },
                                .extra_temps = .{
                                    .{ .type = .f64, .kind = .{ .reg = .st6 } },
                                    .{ .type = .f64, .kind = .{ .reg = .st7 } },
                                    .{ .type = .u16, .kind = .{ .reg = .ax } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .cc = switch (optimized) {
                                    false => .z_and_np,
                                    true => .z,
                                } }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, .f_, .ld, .src1q, ._, ._, ._ },
                                    .{ ._, .f_, .ld, .src0q, ._, ._, ._ },
                                    .{ ._, .f_pp, .ucom, ._, ._, ._, ._ },
                                    .{ ._, .fn_sw, .st, .tmp2w, ._, ._, ._ },
                                    .{ ._, ._, .sahf, ._, ._, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .x87, null, null, null },
                                .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword }, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .f64, .kind = .{ .reg = .st6 } },
                                    .{ .type = .f64, .kind = .{ .reg = .st7 } },
                                    .{ .type = .u16, .kind = .{ .reg = .ax } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .cc = switch (optimized) {
                                    false => .z,
                                    true => .nz,
                                } }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = switch (optimized) {
                                    false => &.{
                                        .{ ._, .f_, .ld, .src1q, ._, ._, ._ },
                                        .{ ._, .f_, .ld, .src0q, ._, ._, ._ },
                                        .{ ._, .f_pp, .ucom, ._, ._, ._, ._ },
                                        .{ ._, .fn_sw, .st, .tmp2w, ._, ._, ._ },
                                        .{ ._, ._, .xor, .tmp2h, .si(0b1_000_000), ._, ._ },
                                        .{ ._, ._, .@"test", .tmp2h, .si(0b1_000_100), ._, ._ },
                                    },
                                    true => &.{
                                        .{ ._, .f_, .ld, .src1q, ._, ._, ._ },
                                        .{ ._, .f_, .ld, .src0q, ._, ._, ._ },
                                        .{ ._, .f_pp, .ucom, ._, ._, ._, ._ },
                                        .{ ._, .fn_sw, .st, .tmp2w, ._, ._, ._ },
                                        .{ ._, ._, .@"test", .tmp2h, .si(0b1_000_000), ._, ._ },
                                    },
                                } },
                            }, .{
                                .required_features = .{ .x87, .cmov, null, null },
                                .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte }, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } },
                                    .{ .src = .{ .mem, .to_x87, .none } },
                                    .{ .src = .{ .to_x87, .to_x87, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .f80, .kind = .{ .reg = .st7 } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .cc = switch (optimized) {
                                    false => .z_and_np,
                                    true => .z,
                                } }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                                    .{ ._, .f_p, .ucomi, .tmp0t, .src1t, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .sahf, .x87, null, null },
                                .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte }, .any },
                                .patterns = &.{
                                    .{ .src = .{ .mem, .mem, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .f80, .kind = .{ .reg = .st6 } },
                                    .{ .type = .f80, .kind = .{ .reg = .st7 } },
                                    .{ .type = .u16, .kind = .{ .reg = .ax } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .cc = switch (optimized) {
                                    false => .z_and_np,
                                    true => .z,
                                } }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
                                    .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                                    .{ ._, .f_pp, .ucom, ._, ._, ._, ._ },
                                    .{ ._, .fn_sw, .st, .tmp2w, ._, ._, ._ },
                                    .{ ._, ._, .sahf, ._, ._, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .sahf, .x87, null, null },
                                .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte }, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } },
                                    .{ .src = .{ .mem, .to_x87, .none } },
                                    .{ .src = .{ .to_x87, .to_x87, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .f80, .kind = .{ .reg = .st6 } },
                                    .{ .type = .f80, .kind = .{ .reg = .st7 } },
                                    .{ .type = .u16, .kind = .{ .reg = .ax } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .cc = switch (optimized) {
                                    false => .z_and_np,
                                    true => .z,
                                } }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                                    .{ ._, .f_p, .ucom, .src1t, ._, ._, ._ },
                                    .{ ._, .fn_sw, .st, .tmp2w, ._, ._, ._ },
                                    .{ ._, ._, .sahf, ._, ._, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .x87, null, null, null },
                                .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte }, .any },
                                .patterns = &.{
                                    .{ .src = .{ .mem, .mem, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .f80, .kind = .{ .reg = .st6 } },
                                    .{ .type = .f80, .kind = .{ .reg = .st7 } },
                                    .{ .type = .u16, .kind = .{ .reg = .ax } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .cc = switch (optimized) {
                                    false => .z,
                                    true => .nz,
                                } }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = switch (optimized) {
                                    false => &.{
                                        .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
                                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                                        .{ ._, .f_pp, .ucom, ._, ._, ._, ._ },
                                        .{ ._, .fn_sw, .st, .tmp2w, ._, ._, ._ },
                                        .{ ._, ._, .xor, .tmp2h, .si(0b1_000_000), ._, ._ },
                                        .{ ._, ._, .@"test", .tmp2h, .si(0b1_000_100), ._, ._ },
                                    },
                                    true => &.{
                                        .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
                                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                                        .{ ._, .f_pp, .ucom, ._, ._, ._, ._ },
                                        .{ ._, .fn_sw, .st, .tmp2w, ._, ._, ._ },
                                        .{ ._, ._, .@"test", .tmp2h, .si(0b1_000_000), ._, ._ },
                                    },
                                } },
                            }, .{
                                .required_features = .{ .x87, null, null, null },
                                .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte }, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } },
                                    .{ .src = .{ .mem, .to_x87, .none } },
                                    .{ .src = .{ .to_x87, .to_x87, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .f80, .kind = .{ .reg = .st6 } },
                                    .{ .type = .f80, .kind = .{ .reg = .st7 } },
                                    .{ .type = .u16, .kind = .{ .reg = .ax } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .cc = switch (optimized) {
                                    false => .z,
                                    true => .nz,
                                } }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = switch (optimized) {
                                    false => &.{
                                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                                        .{ ._, .f_p, .ucom, .src1t, ._, ._, ._ },
                                        .{ ._, .fn_sw, .st, .tmp2w, ._, ._, ._ },
                                        .{ ._, ._, .xor, .tmp2h, .si(0b1_000_000), ._, ._ },
                                        .{ ._, ._, .@"test", .tmp2h, .si(0b1_000_100), ._, ._ },
                                    },
                                    true => &.{
                                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                                        .{ ._, .f_p, .ucom, .src1t, ._, ._, ._ },
                                        .{ ._, .fn_sw, .st, .tmp2w, ._, ._, ._ },
                                        .{ ._, ._, .@"test", .tmp2h, .si(0b1_000_000), ._, ._ },
                                    },
                                } },
                            }, .{
                                .required_cc_abi = .sysv64,
                                .required_features = .{ .sse, null, null, null },
                                .src_constraints = .{ .{ .float = .xword }, .{ .float = .xword }, .any },
                                .patterns = &.{
                                    .{ .src = .{
                                        .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                                        .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                                        .none,
                                    } },
                                },
                                .call_frame = .{ .alignment = .@"16" },
                                .extra_temps = .{
                                    .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                    .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .cc = .z }, .unused },
                                .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .tmp1d, ._, ._ },
                                } },
                            }, .{
                                .required_cc_abi = .win64,
                                .required_features = .{ .sse, null, null, null },
                                .src_constraints = .{ .{ .float = .xword }, .{ .float = .xword }, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none } },
                                },
                                .call_frame = .{ .alignment = .@"16" },
                                .extra_temps = .{
                                    .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                    .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                    .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .cc = .z }, .unused },
                                .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                                    .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                                    .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp3d, .tmp3d, ._, ._ },
                                } },
                            } },
                        }) catch |err| break :err err;
                        switch (cmp_op) {
                            else => unreachable,
                            .eq => {},
                            .neq => {
                                const cc = &res[0].unwrap(cg).temp.tracking(cg).short.eflags;
                                cc.* = cc.negate();
                            },
                        }
                    },
                    .int => {
                        switch (ty.zigTypeTag(zcu)) {
                            else => {},
                            .@"struct", .@"union" => {
                                assert(ty.containerLayout(zcu) == .@"packed");
                                for (&ops) |*op| op.wrapInt(cg) catch |err| switch (err) {
                                    error.SelectFailed => return cg.fail("failed to select {s} wrap {f} {f}", .{
                                        @tagName(air_tag),
                                        ty.fmt(pt),
                                        op.tracking(cg),
                                    }),
                                    else => |e| return e,
                                };
                            },
                        }
                        res[0] = ops[0].cmpInts(cmp_op, &ops[1], cg) catch |err| break :err err;
                    },
                }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f} {f}", .{
                        @tagName(air_tag),
                        ty.fmt(pt),
                        ops[0].tracking(cg),
                        ops[1].tracking(cg),
                    }),
                    else => |e| return e,
                };
                if (opt_info) |*oi| {
                    for (ops) |op| for (res) |r| {
                        if (op.index == r.index) break;
                    } else try op.die(cg);
                    try cg.genCopy(.bool, oi.res[0].tracking(cg).short, res[0].tracking(cg).short, .{});
                    try res[0].die(cg);
                    res[0] = oi.res[0];
                    try cg.restoreState(oi.state, &oi.deaths, .{
                        .emit_instructions = true,
                        .update_tracking = true,
                        .resurrect = true,
                        .close_scope = true,
                    });
                    cg.performReloc(oi.reloc);
                    @memset(&ops, res[0]);
                }
                try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
            },
            .cmp_vector, .cmp_vector_optimized => |air_tag| {
                const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
                const vector_cmp = cg.air.extraData(Air.VectorCmp, ty_pl.payload).data;
                var ops = try cg.tempsFromOperands(inst, .{ vector_cmp.lhs, vector_cmp.rhs });
                var res: [1]Temp = undefined;
                (err: switch (vector_cmp.compareOperator()) {
                    .lt, .lte, .gte, .gt => |cmp_op| {
                        switch (cmp_op) {
                            else => unreachable,
                            .lt, .lte => {},
                            .gt, .gte => std.mem.swap(Temp, &ops[0], &ops[1]),
                        }
                        break :err cg.select(&res, &.{ty_pl.ty.toType()}, &ops, switch (@as(Condition, switch (cmp_op) {
                            else => unreachable,
                            .lt, .gt => .l,
                            .lte, .gte => .le,
                        })) {
                            else => unreachable,
                            inline .l, .le => |cc| comptime &.{ .{
                                .required_features = .{ .f16c, null, null, null },
                                .src_constraints = .{
                                    .{ .scalar_float = .{ .of = .word, .is = .word } },
                                    .{ .scalar_float = .{ .of = .word, .is = .word } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_sse, .to_sse, .none } },
                                },
                                .extra_temps = .{
                                    .{ .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .mut_rc_mask = .{
                                    .ref = .src0,
                                    .rc = .sse,
                                    .info = .{ .kind = .all, .scalar = .dword },
                                } }, .unused },
                                .each = .{ .once = &.{
                                    .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                                    .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
                                    .{ ._, .v_ss, .cmp, .dst0x, .dst0x, .tmp0d, .vp(switch (cc) {
                                        else => unreachable,
                                        .l => .lt,
                                        .le => .le,
                                    }) },
                                } },
                            }, .{
                                .required_features = .{ .f16c, null, null, null },
                                .src_constraints = .{
                                    .{ .scalar_float = .{ .of = .qword, .is = .word } },
                                    .{ .scalar_float = .{ .of = .qword, .is = .word } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .mem, .mem, .none } },
                                    .{ .src = .{ .sse, .mem, .none } },
                                    .{ .src = .{ .mem, .sse, .none } },
                                    .{ .src = .{ .to_sse, .to_sse, .none } },
                                },
                                .extra_temps = .{
                                    .{ .kind = .{ .rc = .sse } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .mut_rc_mask = .{
                                    .ref = .src0,
                                    .rc = .sse,
                                    .info = .{ .kind = .all, .scalar = .dword },
                                } }, .unused },
                                .each = .{ .once = &.{
                                    .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                                    .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
                                    .{ ._, .v_ps, .cmp, .dst0x, .dst0x, .tmp0x, .vp(switch (cc) {
                                        else => unreachable,
                                        .l => .lt,
                                        .le => .le,
                                    }) },
                                } },
                            }, .{
                                .required_features = .{ .f16c, null, null, null },
                                .src_constraints = .{
                                    .{ .scalar_float = .{ .of = .xword, .is = .word } },
                                    .{ .scalar_float = .{ .of = .xword, .is = .word } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .mem, .mem, .none } },
                                    .{ .src = .{ .to_sse, .mem, .none } },
                                    .{ .src = .{ .mem, .to_sse, .none } },
                                    .{ .src = .{ .to_sse, .to_sse, .none } },
                                },
                                .extra_temps = .{
                                    .{ .kind = .{ .rc = .sse } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .mut_rc_mask = .{
                                    .ref = .src0,
                                    .rc = .sse,
                                    .info = .{ .kind = .all, .scalar = .dword },
                                } }, .unused },
                                .each = .{ .once = &.{
                                    .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
                                    .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ },
                                    .{ ._, .v_ps, .cmp, .dst0y, .dst0y, .tmp0y, .vp(switch (cc) {
                                        else => unreachable,
                                        .l => .lt,
                                        .le => .le,
                                    }) },
                                } },
                            }, .{
                                .required_features = .{ .avx, null, null, null },
                                .src_constraints = .{
                                    .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                                    .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                                },
                                .dst_temps = .{ .{ .mut_rc_mask = .{
                                    .ref = .src0,
                                    .rc = .sse,
                                    .info = .{ .kind = .all, .scalar = .dword },
                                } }, .unused },
                                .each = .{ .once = &.{
                                    .{ ._, .v_ss, .cmp, .dst0x, .src0x, .src1d, .vp(switch (cc) {
                                        else => unreachable,
                                        .l => .gt,
                                        .le => .ge,
                                    }) },
                                } },
                            }, .{
                                .required_features = .{ .avx, null, null, null },
                                .src_constraints = .{
                                    .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                                    .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_sse, .mem, .none } },
                                    .{ .src = .{ .to_sse, .to_sse, .none } },
                                },
                                .dst_temps = .{ .{ .mut_rc_mask = .{
                                    .ref = .src0,
                                    .rc = .sse,
                                    .info = .{ .kind = .all, .scalar = .dword },
                                } }, .unused },
                                .each = .{ .once = &.{
                                    .{ ._, .v_ss, .cmp, .dst0x, .src0x, .src1d, .vp(switch (cc) {
                                        else => unreachable,
                                        .l => .lt,
                                        .le => .le,
                                    }) },
                                } },
                            }, .{
                                .required_features = .{ .sse, null, null, null },
                                .src_constraints = .{
                                    .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                                    .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_mut_sse, .mem, .none } },
                                    .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                                },
                                .dst_temps = .{ .{ .ref_mask = .{
                                    .ref = .src0,
                                    .info = .{ .kind = .all, .scalar = .dword },
                                } }, .unused },
                                .each = .{ .once = &.{
                                    .{ ._, ._ss, .cmp, .dst0x, .src1d, .sp(switch (cc) {
                                        else => unreachable,
                                        .l => .lt,
                                        .le => .le,
                                    }), ._ },
                                } },
                            }, .{
                                .required_features = .{ .avx, null, null, null },
                                .src_constraints = .{
                                    .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                                    .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                                },
                                .dst_temps = .{ .{ .mut_rc_mask = .{
                                    .ref = .src0,
                                    .rc = .sse,
                                    .info = .{ .kind = .all, .scalar = .dword },
                                } }, .unused },
                                .each = .{ .once = &.{
                                    .{ ._, .v_ps, .cmp, .dst0x, .src0x, .src1x, .vp(switch (cc) {
                                        else => unreachable,
                                        .l => .gt,
                                        .le => .ge,
                                    }) },
                                } },
                            }, .{
                                .required_features = .{ .avx, null, null, null },
                                .src_constraints = .{
                                    .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                                    .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_sse, .mem, .none } },
                                    .{ .src = .{ .to_sse, .to_sse, .none } },
                                },
                                .dst_temps = .{ .{ .mut_rc_mask = .{
                                    .ref = .src0,
                                    .rc = .sse,
                                    .info = .{ .kind = .all, .scalar = .dword },
                                } }, .unused },
                                .each = .{ .once = &.{
                                    .{ ._, .v_ps, .cmp, .dst0x, .src0x, .src1x, .vp(switch (cc) {
                                        else => unreachable,
                                        .l => .lt,
                                        .le => .le,
                                    }) },
                                } },
                            }, .{
                                .required_features = .{ .sse, null, null, null },
                                .src_constraints = .{
                                    .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                                    .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_mut_sse, .mem, .none } },
                                    .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                                },
                                .dst_temps = .{ .{ .ref_mask = .{
                                    .ref = .src0,
                                    .info = .{ .kind = .all, .scalar = .dword },
                                } }, .unused },
                                .each = .{ .once = &.{
                                    .{ ._, ._ps, .cmp, .dst0x, .src1x, .sp(switch (cc) {
                                        else => unreachable,
                                        .l => .lt,
                                        .le => .le,
                                    }), ._ },
                                } },
                            }, .{
                                .required_features = .{ .avx, null, null, null },
                                .src_constraints = .{
                                    .{ .scalar_float = .{ .of = .yword, .is = .dword } },
                                    .{ .scalar_float = .{ .of = .yword, .is = .dword } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                                },
                                .dst_temps = .{ .{ .mut_rc_mask = .{
                                    .ref = .src0,
                                    .rc = .sse,
                                    .info = .{ .kind = .all, .scalar = .dword },
                                } }, .unused },
                                .each = .{ .once = &.{
                                    .{ ._, .v_ps, .cmp, .dst0y, .src0y, .src1y, .vp(switch (cc) {
                                        else => unreachable,
                                        .l => .gt,
                                        .le => .ge,
                                    }) },
                                } },
                            }, .{
                                .required_features = .{ .avx, null, null, null },
                                .src_constraints = .{
                                    .{ .scalar_float = .{ .of = .yword, .is = .dword } },
                                    .{ .scalar_float = .{ .of = .yword, .is = .dword } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_sse, .mem, .none } },
                                    .{ .src = .{ .to_sse, .to_sse, .none } },
                                },
                                .dst_temps = .{ .{ .mut_rc_mask = .{
                                    .ref = .src0,
                                    .rc = .sse,
                                    .info = .{ .kind = .all, .scalar = .dword },
                                } }, .unused },
                                .each = .{ .once = &.{
                                    .{ ._, .v_ps, .cmp, .dst0y, .src0y, .src1y, .vp(switch (cc) {
                                        else => unreachable,
                                        .l => .lt,
                                        .le => .le,
                                    }) },
                                } },
                            }, .{
                                .required_features = .{ .avx, null, null, null },
                                .src_constraints = .{
                                    .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                                    .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                                },
                                .dst_temps = .{ .{ .mut_rc_mask = .{
                                    .ref = .src0,
                                    .rc = .sse,
                                    .info = .{ .kind = .all, .scalar = .qword },
                                } }, .unused },
                                .each = .{ .once = &.{
                                    .{ ._, .v_sd, .cmp, .dst0x, .src0x, .src1q, .vp(switch (cc) {
                                        else => unreachable,
                                        .l => .gt,
                                        .le => .ge,
                                    }) },
                                } },
                            }, .{
                                .required_features = .{ .avx, null, null, null },
                                .src_constraints = .{
                                    .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                                    .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_sse, .mem, .none } },
                                    .{ .src = .{ .to_sse, .to_sse, .none } },
                                },
                                .dst_temps = .{ .{ .mut_rc_mask = .{
                                    .ref = .src0,
                                    .rc = .sse,
                                    .info = .{ .kind = .all, .scalar = .qword },
                                } }, .unused },
                                .each = .{ .once = &.{
                                    .{ ._, .v_sd, .cmp, .dst0x, .src0x, .src1q, .vp(switch (cc) {
                                        else => unreachable,
                                        .l => .lt,
                                        .le => .le,
                                    }) },
                                } },
                            }, .{
                                .required_features = .{ .sse2, null, null, null },
                                .src_constraints = .{
                                    .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                                    .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_mut_sse, .mem, .none } },
                                    .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                                },
                                .dst_temps = .{ .{ .ref_mask = .{
                                    .ref = .src0,
                                    .info = .{ .kind = .all, .scalar = .qword },
                                } }, .unused },
                                .each = .{ .once = &.{
                                    .{ ._, ._sd, .cmp, .dst0x, .src1q, .sp(switch (cc) {
                                        else => unreachable,
                                        .l => .lt,
                                        .le => .le,
                                    }), ._ },
                                } },
                            }, .{
                                .required_features = .{ .avx, null, null, null },
                                .src_constraints = .{
                                    .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                                    .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                                },
                                .dst_temps = .{ .{ .mut_rc_mask = .{
                                    .ref = .src0,
                                    .rc = .sse,
                                    .info = .{ .kind = .all, .scalar = .qword },
                                } }, .unused },
                                .each = .{ .once = &.{
                                    .{ ._, .v_pd, .cmp, .dst0x, .src0x, .src1x, .vp(switch (cc) {
                                        else => unreachable,
                                        .l => .gt,
                                        .le => .ge,
                                    }) },
                                } },
                            }, .{
                                .required_features = .{ .avx, null, null, null },
                                .src_constraints = .{
                                    .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                                    .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_sse, .mem, .none } },
                                    .{ .src = .{ .to_sse, .to_sse, .none } },
                                },
                                .dst_temps = .{ .{ .mut_rc_mask = .{
                                    .ref = .src0,
                                    .rc = .sse,
                                    .info = .{ .kind = .all, .scalar = .qword },
                                } }, .unused },
                                .each = .{ .once = &.{
                                    .{ ._, .v_pd, .cmp, .dst0x, .src0x, .src1x, .vp(switch (cc) {
                                        else => unreachable,
                                        .l => .lt,
                                        .le => .le,
                                    }) },
                                } },
                            }, .{
                                .required_features = .{ .sse2, null, null, null },
                                .src_constraints = .{
                                    .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                                    .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_mut_sse, .mem, .none } },
                                    .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                                },
                                .dst_temps = .{ .{ .ref_mask = .{
                                    .ref = .src0,
                                    .info = .{ .kind = .all, .scalar = .qword },
                                } }, .unused },
                                .each = .{ .once = &.{
                                    .{ ._, ._pd, .cmp, .dst0x, .src1x, .sp(switch (cc) {
                                        else => unreachable,
                                        .l => .lt,
                                        .le => .le,
                                    }), ._ },
                                } },
                            }, .{
                                .required_features = .{ .avx, null, null, null },
                                .src_constraints = .{
                                    .{ .scalar_float = .{ .of = .yword, .is = .qword } },
                                    .{ .scalar_float = .{ .of = .yword, .is = .qword } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                                },
                                .dst_temps = .{ .{ .mut_rc_mask = .{
                                    .ref = .src0,
                                    .rc = .sse,
                                    .info = .{ .kind = .all, .scalar = .qword },
                                } }, .unused },
                                .each = .{ .once = &.{
                                    .{ ._, .v_pd, .cmp, .dst0y, .src0y, .src1y, .vp(switch (cc) {
                                        else => unreachable,
                                        .l => .gt,
                                        .le => .ge,
                                    }) },
                                } },
                            }, .{
                                .required_features = .{ .avx, null, null, null },
                                .src_constraints = .{
                                    .{ .scalar_float = .{ .of = .yword, .is = .qword } },
                                    .{ .scalar_float = .{ .of = .yword, .is = .qword } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_sse, .mem, .none } },
                                    .{ .src = .{ .to_sse, .to_sse, .none } },
                                },
                                .dst_temps = .{ .{ .mut_rc_mask = .{
                                    .ref = .src0,
                                    .rc = .sse,
                                    .info = .{ .kind = .all, .scalar = .qword },
                                } }, .unused },
                                .each = .{ .once = &.{
                                    .{ ._, .v_pd, .cmp, .dst0y, .src0y, .src1y, .vp(switch (cc) {
                                        else => unreachable,
                                        .l => .lt,
                                        .le => .le,
                                    }) },
                                } },
                            }, .{
                                .required_features = .{ .f16c, .slow_incdec, null, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
                                    .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                                    .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                                    .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .mem, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                                    .{ .@"0:", .v_ps, .cvtph2, .tmp2y, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .v_ps, .cvtph2, .tmp3y, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .v_ps, .cmp, .tmp2y, .tmp2y, .tmp3y, .vp(switch (cc) {
                                        else => unreachable,
                                        .l => .lt,
                                        .le => .le,
                                    }) },
                                    .{ ._, .v_ps, .movmsk, .tmp4d, .tmp2y, ._, ._ },
                                    .{ ._, ._, .mov, .lea(.tmp1b), .tmp4b, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 1), ._, ._ },
                                    .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .f16c, null, null, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
                                    .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                                    .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                                    .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .mem, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                                    .{ .@"0:", .v_ps, .cvtph2, .tmp2y, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .v_ps, .cvtph2, .tmp3y, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .v_ps, .cmp, .tmp2y, .tmp2y, .tmp3y, .vp(switch (cc) {
                                        else => unreachable,
                                        .l => .lt,
                                        .le => .le,
                                    }) },
                                    .{ ._, .v_ps, .movmsk, .tmp4d, .tmp2y, ._, ._ },
                                    .{ ._, ._, .mov, .lea(.tmp1b), .tmp4b, ._, ._ },
                                    .{ ._, ._c, .in, .tmp1p, ._, ._, ._ },
                                    .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .avx, .slow_incdec, null, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                    .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                    .any,
                                },
                                .dst_constraints = .{ .{ .bool_vec = .dword }, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none } },
                                },
                                .call_frame = .{ .alignment = .@"16" },
                                .extra_temps = .{
                                    .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                    .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                    .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .u8, .kind = .{ .reg = .cl } },
                                    .{ .type = .u32, .kind = .{ .reg = .edx } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                                .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                                    .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ },
                                    .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memsi(.src0w, .@"2", .tmp0), .ui(0) },
                                    .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memsi(.src1w, .@"2", .tmp0), .ui(0) },
                                    .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                                    .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ },
                                    .{ ._, .fromCond(cc), .set, .tmp6b, ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                                    .{ ._, ._l, .sh, .tmp6d, .tmp5b, ._, ._ },
                                    .{ ._, ._, .@"or", .dst0d, .tmp6d, ._, ._ },
                                    .{ ._, ._, .add, .tmp0d, .si(1), ._, ._ },
                                    .{ ._, ._, .cmp, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                                    .{ ._, ._b, .j, .@"0b", ._, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .avx, null, null, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                    .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                    .any,
                                },
                                .dst_constraints = .{ .{ .bool_vec = .dword }, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none } },
                                },
                                .call_frame = .{ .alignment = .@"16" },
                                .extra_temps = .{
                                    .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                    .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                    .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .u8, .kind = .{ .reg = .cl } },
                                    .{ .type = .u32, .kind = .{ .reg = .edx } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                                .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                                    .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ },
                                    .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memsi(.src0w, .@"2", .tmp0), .ui(0) },
                                    .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memsi(.src1w, .@"2", .tmp0), .ui(0) },
                                    .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                                    .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ },
                                    .{ ._, .fromCond(cc), .set, .tmp6b, ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                                    .{ ._, ._l, .sh, .tmp6d, .tmp5b, ._, ._ },
                                    .{ ._, ._, .@"or", .dst0d, .tmp6d, ._, ._ },
                                    .{ ._, ._c, .in, .tmp0d, ._, ._, ._ },
                                    .{ ._, ._, .cmp, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                                    .{ ._, ._b, .j, .@"0b", ._, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .sse2, .slow_incdec, null, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                    .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                    .any,
                                },
                                .dst_constraints = .{ .{ .bool_vec = .dword }, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none } },
                                },
                                .call_frame = .{ .alignment = .@"16" },
                                .extra_temps = .{
                                    .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                    .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                    .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .u8, .kind = .{ .reg = .cl } },
                                    .{ .type = .u32, .kind = .{ .reg = .edx } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                                .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                                    .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                                    .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
                                    .{ ._, .p_w, .insr, .tmp1x, .memsi(.src0w, .@"2", .tmp0), .ui(0), ._ },
                                    .{ ._, .p_w, .insr, .tmp2x, .memsi(.src1w, .@"2", .tmp0), .ui(0), ._ },
                                    .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                                    .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ },
                                    .{ ._, .fromCond(cc), .set, .tmp6b, ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                                    .{ ._, ._l, .sh, .tmp6d, .tmp5b, ._, ._ },
                                    .{ ._, ._, .@"or", .dst0d, .tmp6d, ._, ._ },
                                    .{ ._, ._, .add, .tmp0d, .si(1), ._, ._ },
                                    .{ ._, ._, .cmp, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                                    .{ ._, ._b, .j, .@"0b", ._, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .sse2, null, null, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                    .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                    .any,
                                },
                                .dst_constraints = .{ .{ .bool_vec = .dword }, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none } },
                                },
                                .call_frame = .{ .alignment = .@"16" },
                                .extra_temps = .{
                                    .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                    .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                    .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .u8, .kind = .{ .reg = .cl } },
                                    .{ .type = .u32, .kind = .{ .reg = .edx } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                                .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                                    .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                                    .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
                                    .{ ._, .p_w, .insr, .tmp1x, .memsi(.src0w, .@"2", .tmp0), .ui(0), ._ },
                                    .{ ._, .p_w, .insr, .tmp2x, .memsi(.src1w, .@"2", .tmp0), .ui(0), ._ },
                                    .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                                    .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ },
                                    .{ ._, .fromCond(cc), .set, .tmp6b, ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                                    .{ ._, ._l, .sh, .tmp6d, .tmp5b, ._, ._ },
                                    .{ ._, ._, .@"or", .dst0d, .tmp6d, ._, ._ },
                                    .{ ._, ._c, .in, .tmp0d, ._, ._, ._ },
                                    .{ ._, ._, .cmp, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                                    .{ ._, ._b, .j, .@"0b", ._, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .sse, .slow_incdec, null, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                    .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                    .any,
                                },
                                .dst_constraints = .{ .{ .bool_vec = .dword }, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none } },
                                },
                                .call_frame = .{ .alignment = .@"16" },
                                .extra_temps = .{
                                    .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                    .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                    .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .u8, .kind = .{ .reg = .cl } },
                                    .{ .type = .u32, .kind = .{ .reg = .edx } },
                                    .{ .type = .f32, .kind = .mem },
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                                .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                                    .{ .@"0:", ._, .movzx, .tmp4d, .memsi(.src0w, .@"2", .tmp0), ._, ._ },
                                    .{ ._, ._, .mov, .mem(.tmp7d), .tmp4d, ._, ._ },
                                    .{ ._, ._ss, .mov, .tmp1x, .mem(.tmp7d), ._, ._ },
                                    .{ ._, ._, .movzx, .tmp4d, .memsi(.src1w, .@"2", .tmp0), ._, ._ },
                                    .{ ._, ._, .mov, .mem(.tmp7d), .tmp4d, ._, ._ },
                                    .{ ._, ._ss, .mov, .tmp2x, .mem(.tmp7d), ._, ._ },
                                    .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                                    .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ },
                                    .{ ._, .fromCond(cc), .set, .tmp6b, ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                                    .{ ._, ._l, .sh, .tmp6d, .tmp5b, ._, ._ },
                                    .{ ._, ._, .@"or", .dst0d, .tmp6d, ._, ._ },
                                    .{ ._, ._, .add, .tmp0d, .si(1), ._, ._ },
                                    .{ ._, ._, .cmp, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                                    .{ ._, ._b, .j, .@"0b", ._, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .sse, null, null, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                    .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                    .any,
                                },
                                .dst_constraints = .{ .{ .bool_vec = .dword }, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none } },
                                },
                                .call_frame = .{ .alignment = .@"16" },
                                .extra_temps = .{
                                    .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                    .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                    .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .u8, .kind = .{ .reg = .cl } },
                                    .{ .type = .u32, .kind = .{ .reg = .edx } },
                                    .{ .type = .f32, .kind = .mem },
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                                .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                                    .{ .@"0:", ._, .movzx, .tmp4d, .memsi(.src0w, .@"2", .tmp0), ._, ._ },
                                    .{ ._, ._, .mov, .mem(.tmp7d), .tmp4d, ._, ._ },
                                    .{ ._, ._ss, .mov, .tmp1x, .mem(.tmp7d), ._, ._ },
                                    .{ ._, ._, .movzx, .tmp4d, .memsi(.src1w, .@"2", .tmp0), ._, ._ },
                                    .{ ._, ._, .mov, .mem(.tmp7d), .tmp4d, ._, ._ },
                                    .{ ._, ._ss, .mov, .tmp2x, .mem(.tmp7d), ._, ._ },
                                    .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                                    .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ },
                                    .{ ._, .fromCond(cc), .set, .tmp6b, ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                                    .{ ._, ._l, .sh, .tmp6d, .tmp5b, ._, ._ },
                                    .{ ._, ._, .@"or", .dst0d, .tmp6d, ._, ._ },
                                    .{ ._, ._c, .in, .tmp0d, ._, ._, ._ },
                                    .{ ._, ._, .cmp, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                                    .{ ._, ._b, .j, .@"0b", ._, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .@"64bit", .avx, .slow_incdec, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                    .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none } },
                                },
                                .call_frame = .{ .alignment = .@"16" },
                                .extra_temps = .{
                                    .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                    .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                    .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .u8, .kind = .{ .reg = .cl } },
                                    .{ .type = .u64, .kind = .{ .reg = .rdx } },
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .mem, .unused },
                                .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ .@"0:", .vp_, .xor, .tmp3x, .tmp3x, .tmp3x, ._ },
                                    .{ ._, .vp_w, .insr, .tmp2x, .tmp3x, .memsi(.src0w, .@"2", .tmp0), .ui(0) },
                                    .{ ._, .vp_w, .insr, .tmp3x, .tmp3x, .memsi(.src1w, .@"2", .tmp0), .ui(0) },
                                    .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                                    .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ },
                                    .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ },
                                    .{ ._, ._l, .sh, .tmp7q, .tmp6b, ._, ._ },
                                    .{ ._, ._, .@"or", .tmp1q, .tmp7q, ._, ._ },
                                    .{ ._, ._, .lea, .tmp0d, .lead(.tmp0, 1), ._, ._ },
                                    .{ ._, ._, .@"test", .tmp0d, .si(0b111111), ._, ._ },
                                    .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp5d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memid(.dst0q, .tmp5, -8), .tmp1q, ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ .@"1:", ._, .cmp, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                                    .{ ._, ._b, .j, .@"0b", ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp0d, .si(0b111111), ._, ._ },
                                    .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                                    .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp1q, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .@"64bit", .avx, null, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                    .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none } },
                                },
                                .call_frame = .{ .alignment = .@"16" },
                                .extra_temps = .{
                                    .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                    .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                    .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .u8, .kind = .{ .reg = .cl } },
                                    .{ .type = .u64, .kind = .{ .reg = .rdx } },
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .mem, .unused },
                                .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ .@"0:", .vp_, .xor, .tmp3x, .tmp3x, .tmp3x, ._ },
                                    .{ ._, .vp_w, .insr, .tmp2x, .tmp3x, .memsi(.src0w, .@"2", .tmp0), .ui(0) },
                                    .{ ._, .vp_w, .insr, .tmp3x, .tmp3x, .memsi(.src1w, .@"2", .tmp0), .ui(0) },
                                    .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                                    .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ },
                                    .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ },
                                    .{ ._, ._l, .sh, .tmp7q, .tmp6b, ._, ._ },
                                    .{ ._, ._, .@"or", .tmp1q, .tmp7q, ._, ._ },
                                    .{ ._, ._c, .in, .tmp0d, ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp0d, .si(0b111111), ._, ._ },
                                    .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp5d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memid(.dst0q, .tmp5, -8), .tmp1q, ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ .@"1:", ._, .cmp, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                                    .{ ._, ._b, .j, .@"0b", ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp0d, .si(0b111111), ._, ._ },
                                    .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                                    .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp1q, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .@"64bit", .sse2, .slow_incdec, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                    .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none } },
                                },
                                .call_frame = .{ .alignment = .@"16" },
                                .extra_temps = .{
                                    .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                    .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                    .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .u8, .kind = .{ .reg = .cl } },
                                    .{ .type = .u64, .kind = .{ .reg = .rdx } },
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .mem, .unused },
                                .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ .@"0:", .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
                                    .{ ._, .p_w, .insr, .tmp2x, .memsi(.src0w, .@"2", .tmp0), .ui(0), ._ },
                                    .{ ._, .p_, .xor, .tmp3x, .tmp3x, ._, ._ },
                                    .{ ._, .p_w, .insr, .tmp3x, .memsi(.src1w, .@"2", .tmp0), .ui(0), ._ },
                                    .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                                    .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ },
                                    .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ },
                                    .{ ._, ._l, .sh, .tmp7q, .tmp6b, ._, ._ },
                                    .{ ._, ._, .@"or", .tmp1q, .tmp7q, ._, ._ },
                                    .{ ._, ._, .lea, .tmp0d, .lead(.tmp0, 1), ._, ._ },
                                    .{ ._, ._, .@"test", .tmp0d, .si(0b111111), ._, ._ },
                                    .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp5d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memid(.dst0q, .tmp5, -8), .tmp1q, ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ .@"1:", ._, .cmp, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                                    .{ ._, ._b, .j, .@"0b", ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp0d, .si(0b111111), ._, ._ },
                                    .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                                    .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp1q, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .@"64bit", .sse2, null, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                    .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none } },
                                },
                                .call_frame = .{ .alignment = .@"16" },
                                .extra_temps = .{
                                    .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                    .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                    .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .u8, .kind = .{ .reg = .cl } },
                                    .{ .type = .u64, .kind = .{ .reg = .rdx } },
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .mem, .unused },
                                .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ .@"0:", .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
                                    .{ ._, .p_w, .insr, .tmp2x, .memsi(.src0w, .@"2", .tmp0), .ui(0), ._ },
                                    .{ ._, .p_, .xor, .tmp3x, .tmp3x, ._, ._ },
                                    .{ ._, .p_w, .insr, .tmp3x, .memsi(.src1w, .@"2", .tmp0), .ui(0), ._ },
                                    .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                                    .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ },
                                    .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ },
                                    .{ ._, ._l, .sh, .tmp7q, .tmp6b, ._, ._ },
                                    .{ ._, ._, .@"or", .tmp1q, .tmp7q, ._, ._ },
                                    .{ ._, ._c, .in, .tmp0d, ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp0d, .si(0b111111), ._, ._ },
                                    .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp5d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memid(.dst0q, .tmp5, -8), .tmp1q, ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ .@"1:", ._, .cmp, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                                    .{ ._, ._b, .j, .@"0b", ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp0d, .si(0b111111), ._, ._ },
                                    .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                                    .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp1q, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .@"64bit", .sse, .slow_incdec, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                    .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none } },
                                },
                                .call_frame = .{ .alignment = .@"16" },
                                .extra_temps = .{
                                    .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                    .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                    .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .u8, .kind = .{ .reg = .cl } },
                                    .{ .type = .u64, .kind = .{ .reg = .rdx } },
                                    .{ .type = .f32, .kind = .mem },
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .mem, .unused },
                                .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ .@"0:", ._, .movzx, .tmp5d, .memsi(.src0w, .@"2", .tmp0), ._, ._ },
                                    .{ ._, ._, .mov, .mem(.tmp8d), .tmp5d, ._, ._ },
                                    .{ ._, ._ss, .mov, .tmp2x, .mem(.tmp8d), ._, ._ },
                                    .{ ._, ._, .movzx, .tmp5d, .memsi(.src1w, .@"2", .tmp0), ._, ._ },
                                    .{ ._, ._, .mov, .mem(.tmp8d), .tmp5d, ._, ._ },
                                    .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp8d), ._, ._ },
                                    .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                                    .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ },
                                    .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ },
                                    .{ ._, ._l, .sh, .tmp7q, .tmp6b, ._, ._ },
                                    .{ ._, ._, .@"or", .tmp1q, .tmp7q, ._, ._ },
                                    .{ ._, ._, .lea, .tmp0d, .lead(.tmp0, 1), ._, ._ },
                                    .{ ._, ._, .@"test", .tmp0d, .si(0b111111), ._, ._ },
                                    .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp5d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memid(.dst0q, .tmp5, -8), .tmp1q, ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ .@"1:", ._, .cmp, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                                    .{ ._, ._b, .j, .@"0b", ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp0d, .si(0b111111), ._, ._ },
                                    .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                                    .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp1q, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .@"64bit", .sse, null, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                    .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none } },
                                },
                                .call_frame = .{ .alignment = .@"16" },
                                .extra_temps = .{
                                    .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                    .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                    .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .u8, .kind = .{ .reg = .cl } },
                                    .{ .type = .u64, .kind = .{ .reg = .rdx } },
                                    .{ .type = .f32, .kind = .mem },
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .mem, .unused },
                                .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ .@"0:", ._, .movzx, .tmp5d, .memsi(.src0w, .@"2", .tmp0), ._, ._ },
                                    .{ ._, ._, .mov, .mem(.tmp8d), .tmp5d, ._, ._ },
                                    .{ ._, ._ss, .mov, .tmp2x, .mem(.tmp8d), ._, ._ },
                                    .{ ._, ._, .movzx, .tmp5d, .memsi(.src1w, .@"2", .tmp0), ._, ._ },
                                    .{ ._, ._, .mov, .mem(.tmp8d), .tmp5d, ._, ._ },
                                    .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp8d), ._, ._ },
                                    .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                                    .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ },
                                    .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ },
                                    .{ ._, ._l, .sh, .tmp7q, .tmp6b, ._, ._ },
                                    .{ ._, ._, .@"or", .tmp1q, .tmp7q, ._, ._ },
                                    .{ ._, ._c, .in, .tmp0d, ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp0d, .si(0b111111), ._, ._ },
                                    .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp5d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memid(.dst0q, .tmp5, -8), .tmp1q, ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ .@"1:", ._, .cmp, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                                    .{ ._, ._b, .j, .@"0b", ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp0d, .si(0b111111), ._, ._ },
                                    .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                                    .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp1q, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .avx, .slow_incdec, null, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
                                    .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                                    .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .mem, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                                    .{ .@"0:", .v_ps, .mova, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .v_ps, .cmp, .tmp2y, .tmp2y, .memia(.src1y, .tmp0, .add_size), .vp(switch (cc) {
                                        else => unreachable,
                                        .l => .lt,
                                        .le => .le,
                                    }) },
                                    .{ ._, .v_ps, .movmsk, .tmp3d, .tmp2y, ._, ._ },
                                    .{ ._, ._, .mov, .lea(.tmp1b), .tmp3b, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 1), ._, ._ },
                                    .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .avx, null, null, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
                                    .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                                    .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .mem, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                                    .{ .@"0:", .v_ps, .mova, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .v_ps, .cmp, .tmp2y, .tmp2y, .memia(.src1y, .tmp0, .add_size), .vp(switch (cc) {
                                        else => unreachable,
                                        .l => .lt,
                                        .le => .le,
                                    }) },
                                    .{ ._, .v_ps, .movmsk, .tmp3d, .tmp2y, ._, ._ },
                                    .{ ._, ._, .mov, .lea(.tmp1b), .tmp3b, ._, ._ },
                                    .{ ._, ._c, .in, .tmp1q, ._, ._, ._ },
                                    .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .sse2, null, null, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
                                    .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                                    .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                                    .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .mem, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                                    .{ .@"0:", ._ps, .mova, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, ._ps, .mova, .tmp3x, .memiad(.src0x, .tmp0, .add_size, 16), ._, ._ },
                                    .{ ._, ._ps, .cmp, .tmp2x, .memia(.src1x, .tmp0, .add_size), .sp(switch (cc) {
                                        else => unreachable,
                                        .l => .lt,
                                        .le => .le,
                                    }), ._ },
                                    .{ ._, ._ps, .cmp, .tmp3x, .memiad(.src1x, .tmp0, .add_size, 16), .sp(switch (cc) {
                                        else => unreachable,
                                        .l => .lt,
                                        .le => .le,
                                    }), ._ },
                                    .{ ._, .p_w, .ackssd, .tmp2x, .tmp3x, ._, ._ },
                                    .{ ._, .p_b, .ackssw, .tmp2x, .tmp2x, ._, ._ },
                                    .{ ._, .p_b, .movmsk, .tmp4d, .tmp2x, ._, ._ },
                                    .{ ._, ._, .mov, .lea(.tmp1b), .tmp4b, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 1), ._, ._ },
                                    .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .sse, null, null, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
                                    .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                                    .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .mem, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                                    .{ .@"0:", ._ps, .mova, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, ._ps, .cmp, .tmp2x, .memia(.src1x, .tmp0, .add_size), .sp(switch (cc) {
                                        else => unreachable,
                                        .l => .lt,
                                        .le => .le,
                                    }), ._ },
                                    .{ ._, ._ps, .movmsk, .tmp3d, .tmp2x, ._, ._ },
                                    .{ ._, ._ps, .mova, .tmp2x, .memiad(.src0x, .tmp0, .add_size, 16), ._, ._ },
                                    .{ ._, ._ps, .cmp, .tmp2x, .memiad(.src1x, .tmp0, .add_size, 16), .sp(switch (cc) {
                                        else => unreachable,
                                        .l => .lt,
                                        .le => .le,
                                    }), ._ },
                                    .{ ._, ._ps, .movmsk, .tmp4d, .tmp2x, ._, ._ },
                                    .{ ._, ._l, .sh, .tmp4b, .ui(4), ._, ._ },
                                    .{ ._, ._, .@"or", .tmp3b, .tmp4b, ._, ._ },
                                    .{ ._, ._, .mov, .lea(.tmp1b), .tmp3b, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 1), ._, ._ },
                                    .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .sse, null, null, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
                                    .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                                    .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .mem, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                                    .{ ._, ._mp, .j, .@"1f", ._, ._, ._ },
                                    .{ .@"0:", ._ps, .mova, .tmp2x, .memiad(.src0x, .tmp0, .add_size, -16), ._, ._ },
                                    .{ ._, ._ps, .cmp, .tmp2x, .memiad(.src1x, .tmp0, .add_size, -16), .sp(switch (cc) {
                                        else => unreachable,
                                        .l => .lt,
                                        .le => .le,
                                    }), ._ },
                                    .{ ._, ._ps, .movmsk, .tmp4d, .tmp2x, ._, ._ },
                                    .{ ._, ._l, .sh, .tmp4b, .ui(4), ._, ._ },
                                    .{ ._, ._, .@"or", .tmp3b, .tmp4b, ._, ._ },
                                    .{ ._, ._, .mov, .lea(.tmp1b), .tmp3b, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 1), ._, ._ },
                                    .{ .@"1:", ._ps, .mova, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, ._ps, .cmp, .tmp2x, .memia(.src1x, .tmp0, .add_size), .sp(switch (cc) {
                                        else => unreachable,
                                        .l => .lt,
                                        .le => .le,
                                    }), ._ },
                                    .{ ._, ._ps, .movmsk, .tmp3d, .tmp2x, ._, ._ },
                                    .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                    .{ ._, ._, .mov, .lea(.tmp1b), .tmp3b, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .avx, .slow_incdec, null, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .zword, .is = .qword } },
                                    .{ .multiple_scalar_float = .{ .of = .zword, .is = .qword } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                                    .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                                    .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .mem, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                                    .{ .@"0:", .v_pd, .mova, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .v_pd, .mova, .tmp3y, .memiad(.src0y, .tmp0, .add_size, 32), ._, ._ },
                                    .{ ._, .v_pd, .cmp, .tmp2y, .tmp2y, .memia(.src1y, .tmp0, .add_size), .vp(switch (cc) {
                                        else => unreachable,
                                        .l => .lt,
                                        .le => .le,
                                    }) },
                                    .{ ._, .v_pd, .cmp, .tmp3y, .tmp3y, .memiad(.src1y, .tmp0, .add_size, 32), .vp(switch (cc) {
                                        else => unreachable,
                                        .l => .lt,
                                        .le => .le,
                                    }) },
                                    .{ ._, .v_pd, .movmsk, .tmp4d, .tmp2y, ._, ._ },
                                    .{ ._, .v_pd, .movmsk, .tmp5d, .tmp3y, ._, ._ },
                                    .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ },
                                    .{ ._, ._, .@"or", .tmp4b, .tmp5b, ._, ._ },
                                    .{ ._, ._, .mov, .lea(.tmp1b), .tmp4b, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 1), ._, ._ },
                                    .{ ._, ._, .add, .tmp0p, .si(64), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .avx, null, null, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .zword, .is = .qword } },
                                    .{ .multiple_scalar_float = .{ .of = .zword, .is = .qword } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                                    .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                                    .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .mem, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                                    .{ .@"0:", .v_pd, .mova, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .v_pd, .mova, .tmp3y, .memiad(.src0y, .tmp0, .add_size, 32), ._, ._ },
                                    .{ ._, .v_pd, .cmp, .tmp2y, .tmp2y, .memia(.src1y, .tmp0, .add_size), .vp(switch (cc) {
                                        else => unreachable,
                                        .l => .lt,
                                        .le => .le,
                                    }) },
                                    .{ ._, .v_pd, .cmp, .tmp3y, .tmp3y, .memiad(.src1y, .tmp0, .add_size, 32), .vp(switch (cc) {
                                        else => unreachable,
                                        .l => .lt,
                                        .le => .le,
                                    }) },
                                    .{ ._, .v_pd, .movmsk, .tmp4d, .tmp2y, ._, ._ },
                                    .{ ._, .v_pd, .movmsk, .tmp5d, .tmp3y, ._, ._ },
                                    .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ },
                                    .{ ._, ._, .@"or", .tmp4b, .tmp5b, ._, ._ },
                                    .{ ._, ._, .mov, .lea(.tmp1b), .tmp4b, ._, ._ },
                                    .{ ._, ._c, .in, .tmp1q, ._, ._, ._ },
                                    .{ ._, ._, .add, .tmp0p, .si(64), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .avx, null, null, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
                                    .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u32, .kind = .{ .reg = .rcx } },
                                    .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                                    .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .mem, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                    .{ .@"0:", .v_pd, .mova, .tmp3y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .v_pd, .cmp, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_size), .vp(switch (cc) {
                                        else => unreachable,
                                        .l => .lt,
                                        .le => .le,
                                    }) },
                                    .{ ._, .v_pd, .movmsk, .tmp4d, .tmp3y, ._, ._ },
                                    .{ ._, ._l, .ro, .tmp4b, .tmp1b, ._, ._ },
                                    .{ ._, ._, .@"or", .tmp2b, .tmp4b, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 4), ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp4d, .tmp1d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp4d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memid(.dst0b, .tmp4, -1), .tmp2b, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                    .{ .@"1:", ._, .add, .tmp0p, .si(32), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .sse2, null, null, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
                                    .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u32, .kind = .{ .reg = .rcx } },
                                    .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                                    .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .mem, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                    .{ .@"0:", ._pd, .mova, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, ._pd, .cmp, .tmp3x, .memia(.src1x, .tmp0, .add_size), .sp(switch (cc) {
                                        else => unreachable,
                                        .l => .lt,
                                        .le => .le,
                                    }), ._ },
                                    .{ ._, ._pd, .movmsk, .tmp4d, .tmp3x, ._, ._ },
                                    .{ ._, ._l, .ro, .tmp4b, .tmp1b, ._, ._ },
                                    .{ ._, ._, .@"or", .tmp2b, .tmp4b, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 2), ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp4d, .tmp1d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp4d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memid(.dst0b, .tmp4, -1), .tmp2b, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                    .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .x87, .cmov, .slow_incdec, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                                    .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none }, .commute = .{ 0, 1 } },
                                },
                                .extra_temps = .{
                                    .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u32, .kind = .{ .reg = .rcx } },
                                    .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .f64, .kind = .{ .reg = .st6 } },
                                    .{ .type = .f64, .kind = .{ .reg = .st7 } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .mem, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                    .{ .@"0:", ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                                    .{ ._, .f_, .ld, .memia(.src1q, .tmp0, .add_size), ._, ._, ._ },
                                    .{ ._, .f_, .ld, .memia(.src0q, .tmp0, .add_size), ._, ._, ._ },
                                    .{ ._, .f_p, .ucomi, .tmp4t, .tmp5t, ._, ._ },
                                    .{ ._, .f_p, .st, .tmp5t, ._, ._, ._ },
                                    .{ ._, .fromCond(switch (cc) {
                                        else => unreachable,
                                        .l => .a,
                                        .le => .ae,
                                    }), .set, .tmp3b, ._, ._, ._ },
                                    .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ },
                                    .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 1), ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp3d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                    .{ .@"1:", ._, .add, .tmp0p, .si(8), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .x87, .cmov, null, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                                    .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none }, .commute = .{ 0, 1 } },
                                },
                                .extra_temps = .{
                                    .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u32, .kind = .{ .reg = .rcx } },
                                    .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .f64, .kind = .{ .reg = .st6 } },
                                    .{ .type = .f64, .kind = .{ .reg = .st7 } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .mem, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                    .{ .@"0:", ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                                    .{ ._, .f_, .ld, .memia(.src1q, .tmp0, .add_size), ._, ._, ._ },
                                    .{ ._, .f_, .ld, .memia(.src0q, .tmp0, .add_size), ._, ._, ._ },
                                    .{ ._, .f_p, .ucomi, .tmp4t, .tmp5t, ._, ._ },
                                    .{ ._, .f_p, .st, .tmp5t, ._, ._, ._ },
                                    .{ ._, .fromCond(switch (cc) {
                                        else => unreachable,
                                        .l => .a,
                                        .le => .ae,
                                    }), .set, .tmp3b, ._, ._, ._ },
                                    .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ },
                                    .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ },
                                    .{ ._, ._c, .in, .tmp1d, ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp3d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                    .{ .@"1:", ._, .add, .tmp0p, .si(8), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .x87, null, null, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                                    .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none }, .commute = .{ 0, 1 } },
                                },
                                .extra_temps = .{
                                    .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u32, .kind = .{ .reg = .rcx } },
                                    .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .f64, .kind = .{ .reg = .st6 } },
                                    .{ .type = .f64, .kind = .{ .reg = .st7 } },
                                    .{ .type = .u16, .kind = .{ .reg = .ax } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .mem, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                    .{ .@"0:", ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                                    .{ ._, .f_, .ld, .memia(.src1q, .tmp0, .add_size), ._, ._, ._ },
                                    .{ ._, .f_, .ld, .memia(.src0q, .tmp0, .add_size), ._, ._, ._ },
                                    .{ ._, .f_pp, .ucom, ._, ._, ._, ._ },
                                    .{ ._, .fn_sw, .st, .tmp6w, ._, ._, ._ },
                                    switch (cc) {
                                        else => unreachable,
                                        .l => .{ ._, ._, .@"test", .tmp6h, .si(0b1_000_001), ._, ._ },
                                        .le => .{ ._, ._r, .sh, .tmp6h, .ui(1), ._, ._ },
                                    },
                                    .{ ._, .fromCond(switch (cc) {
                                        else => unreachable,
                                        .l => .z,
                                        .le => .nc,
                                    }), .set, .tmp3b, ._, ._, ._ },
                                    .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ },
                                    .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ },
                                    .{ ._, ._c, .in, .tmp1d, ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp3d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                    .{ .@"1:", ._, .add, .tmp0p, .si(8), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .x87, .cmov, .slow_incdec, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                                    .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none }, .commute = .{ 0, 1 } },
                                },
                                .extra_temps = .{
                                    .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u32, .kind = .{ .reg = .rcx } },
                                    .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .f80, .kind = .{ .reg = .st6 } },
                                    .{ .type = .f80, .kind = .{ .reg = .st7 } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .mem, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                    .{ .@"0:", ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                                    .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_size), ._, ._, ._ },
                                    .{ ._, .f_, .ld, .memia(.src0t, .tmp0, .add_size), ._, ._, ._ },
                                    .{ ._, .f_p, .ucomi, .tmp4t, .tmp5t, ._, ._ },
                                    .{ ._, .f_p, .st, .tmp5t, ._, ._, ._ },
                                    .{ ._, .fromCond(switch (cc) {
                                        else => unreachable,
                                        .l => .a,
                                        .le => .ae,
                                    }), .set, .tmp3b, ._, ._, ._ },
                                    .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ },
                                    .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 1), ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp3d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                    .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .x87, .cmov, null, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                                    .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none }, .commute = .{ 0, 1 } },
                                },
                                .extra_temps = .{
                                    .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u32, .kind = .{ .reg = .rcx } },
                                    .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .f80, .kind = .{ .reg = .st6 } },
                                    .{ .type = .f80, .kind = .{ .reg = .st7 } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .mem, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                    .{ .@"0:", ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                                    .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_size), ._, ._, ._ },
                                    .{ ._, .f_, .ld, .memia(.src0t, .tmp0, .add_size), ._, ._, ._ },
                                    .{ ._, .f_p, .ucomi, .tmp4t, .tmp5t, ._, ._ },
                                    .{ ._, .f_p, .st, .tmp5t, ._, ._, ._ },
                                    .{ ._, .fromCond(switch (cc) {
                                        else => unreachable,
                                        .l => .a,
                                        .le => .ae,
                                    }), .set, .tmp3b, ._, ._, ._ },
                                    .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ },
                                    .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ },
                                    .{ ._, ._c, .in, .tmp1d, ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp3d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                    .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .x87, null, null, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                                    .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none }, .commute = .{ 0, 1 } },
                                },
                                .extra_temps = .{
                                    .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u32, .kind = .{ .reg = .rcx } },
                                    .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .f80, .kind = .{ .reg = .st6 } },
                                    .{ .type = .f80, .kind = .{ .reg = .st7 } },
                                    .{ .type = .u16, .kind = .{ .reg = .ax } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .mem, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                    .{ .@"0:", ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                                    .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_size), ._, ._, ._ },
                                    .{ ._, .f_, .ld, .memia(.src0t, .tmp0, .add_size), ._, ._, ._ },
                                    .{ ._, .f_pp, .ucom, ._, ._, ._, ._ },
                                    .{ ._, .fn_sw, .st, .tmp6w, ._, ._, ._ },
                                    switch (cc) {
                                        else => unreachable,
                                        .l => .{ ._, ._, .@"test", .tmp6h, .si(0b1_000_001), ._, ._ },
                                        .le => .{ ._, ._r, .sh, .tmp6h, .ui(1), ._, ._ },
                                    },
                                    .{ ._, .fromCond(switch (cc) {
                                        else => unreachable,
                                        .l => .z,
                                        .le => .nc,
                                    }), .set, .tmp3b, ._, ._, ._ },
                                    .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ },
                                    .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ },
                                    .{ ._, ._c, .in, .tmp1d, ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp3d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                    .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .avx, .slow_incdec, null, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                    .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                    .any,
                                },
                                .dst_constraints = .{ .{ .bool_vec = .dword }, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none } },
                                },
                                .call_frame = .{ .alignment = .@"16" },
                                .extra_temps = .{
                                    .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                    .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                    .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .u8, .kind = .{ .reg = .cl } },
                                    .{ .type = .u32, .kind = .{ .reg = .edx } },
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                                .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ .@"0:", .v_dqa, .mov, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .v_dqa, .mov, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                                    .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ },
                                    .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ },
                                    .{ ._, ._l, .sh, .tmp7d, .tmp6b, ._, ._ },
                                    .{ ._, ._, .@"or", .dst0d, .tmp7d, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 1), ._, ._ },
                                    .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .avx, .slow_incdec, null, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                    .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                    .any,
                                },
                                .dst_constraints = .{ .{ .bool_vec = .dword }, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none } },
                                },
                                .call_frame = .{ .alignment = .@"16" },
                                .extra_temps = .{
                                    .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                    .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                    .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .u8, .kind = .{ .reg = .cl } },
                                    .{ .type = .u32, .kind = .{ .reg = .edx } },
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                                .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ .@"0:", .v_dqa, .mov, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .v_dqa, .mov, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                                    .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ },
                                    .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ },
                                    .{ ._, ._l, .sh, .tmp7d, .tmp6b, ._, ._ },
                                    .{ ._, ._, .@"or", .dst0d, .tmp7d, ._, ._ },
                                    .{ ._, ._c, .in, .tmp1d, ._, ._, ._ },
                                    .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .sse2, .slow_incdec, null, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                    .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                    .any,
                                },
                                .dst_constraints = .{ .{ .bool_vec = .dword }, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none } },
                                },
                                .call_frame = .{ .alignment = .@"16" },
                                .extra_temps = .{
                                    .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                    .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                    .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .u8, .kind = .{ .reg = .cl } },
                                    .{ .type = .u32, .kind = .{ .reg = .edx } },
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                                .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ .@"0:", ._dqa, .mov, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, ._dqa, .mov, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                                    .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ },
                                    .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ },
                                    .{ ._, ._l, .sh, .tmp7d, .tmp6b, ._, ._ },
                                    .{ ._, ._, .@"or", .dst0d, .tmp7d, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 1), ._, ._ },
                                    .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .sse2, .slow_incdec, null, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                    .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                    .any,
                                },
                                .dst_constraints = .{ .{ .bool_vec = .dword }, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none } },
                                },
                                .call_frame = .{ .alignment = .@"16" },
                                .extra_temps = .{
                                    .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                    .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                    .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .u8, .kind = .{ .reg = .cl } },
                                    .{ .type = .u32, .kind = .{ .reg = .edx } },
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                                .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ .@"0:", ._dqa, .mov, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, ._dqa, .mov, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                                    .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ },
                                    .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ },
                                    .{ ._, ._l, .sh, .tmp7d, .tmp6b, ._, ._ },
                                    .{ ._, ._, .@"or", .dst0d, .tmp7d, ._, ._ },
                                    .{ ._, ._c, .in, .tmp1d, ._, ._, ._ },
                                    .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .sse, .slow_incdec, null, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                    .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                    .any,
                                },
                                .dst_constraints = .{ .{ .bool_vec = .dword }, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none } },
                                },
                                .call_frame = .{ .alignment = .@"16" },
                                .extra_temps = .{
                                    .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                    .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                    .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .u8, .kind = .{ .reg = .cl } },
                                    .{ .type = .u32, .kind = .{ .reg = .edx } },
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                                .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ .@"0:", ._ps, .mova, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, ._ps, .mova, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                                    .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ },
                                    .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ },
                                    .{ ._, ._l, .sh, .tmp7d, .tmp6b, ._, ._ },
                                    .{ ._, ._, .@"or", .dst0d, .tmp7d, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 1), ._, ._ },
                                    .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .sse2, .slow_incdec, null, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                    .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                    .any,
                                },
                                .dst_constraints = .{ .{ .bool_vec = .dword }, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none } },
                                },
                                .call_frame = .{ .alignment = .@"16" },
                                .extra_temps = .{
                                    .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                    .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                    .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .u8, .kind = .{ .reg = .cl } },
                                    .{ .type = .u32, .kind = .{ .reg = .edx } },
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                                .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ .@"0:", ._ps, .mova, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, ._ps, .mova, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                                    .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ },
                                    .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ },
                                    .{ ._, ._l, .sh, .tmp7d, .tmp6b, ._, ._ },
                                    .{ ._, ._, .@"or", .dst0d, .tmp7d, ._, ._ },
                                    .{ ._, ._c, .in, .tmp1d, ._, ._, ._ },
                                    .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .@"64bit", .avx, .slow_incdec, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                    .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none } },
                                },
                                .call_frame = .{ .alignment = .@"16" },
                                .extra_temps = .{
                                    .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                    .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                    .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .u8, .kind = .{ .reg = .cl } },
                                    .{ .type = .u64, .kind = .{ .reg = .rdx } },
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .mem, .unused },
                                .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                    .{ .@"0:", .v_dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .v_dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                                    .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp6d, .tmp6d, ._, ._ },
                                    .{ ._, .fromCond(cc), .set, .tmp8b, ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp7d, .tmp1d, ._, ._ },
                                    .{ ._, ._l, .sh, .tmp8q, .tmp7b, ._, ._ },
                                    .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 1), ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111111), ._, ._ },
                                    .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp6d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memid(.dst0q, .tmp6, -8), .tmp2q, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                    .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111111), ._, ._ },
                                    .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1d, .ui(6), ._, ._ },
                                    .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp1), .tmp2q, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .@"64bit", .avx, null, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                    .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none } },
                                },
                                .call_frame = .{ .alignment = .@"16" },
                                .extra_temps = .{
                                    .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                    .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                    .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .u8, .kind = .{ .reg = .cl } },
                                    .{ .type = .u64, .kind = .{ .reg = .rdx } },
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .mem, .unused },
                                .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                    .{ .@"0:", .v_dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .v_dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                                    .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp6d, .tmp6d, ._, ._ },
                                    .{ ._, .fromCond(cc), .set, .tmp8b, ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp7d, .tmp1d, ._, ._ },
                                    .{ ._, ._l, .sh, .tmp8q, .tmp7b, ._, ._ },
                                    .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ },
                                    .{ ._, ._c, .in, .tmp1d, ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111111), ._, ._ },
                                    .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp6d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memid(.dst0q, .tmp6, -8), .tmp2q, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                    .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111111), ._, ._ },
                                    .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1d, .ui(6), ._, ._ },
                                    .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp1), .tmp2q, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .@"64bit", .sse2, .slow_incdec, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                    .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none } },
                                },
                                .call_frame = .{ .alignment = .@"16" },
                                .extra_temps = .{
                                    .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                    .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                    .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .u8, .kind = .{ .reg = .cl } },
                                    .{ .type = .u64, .kind = .{ .reg = .rdx } },
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .mem, .unused },
                                .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                    .{ .@"0:", ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, ._dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                                    .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp6d, .tmp6d, ._, ._ },
                                    .{ ._, .fromCond(cc), .set, .tmp8b, ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp7d, .tmp1d, ._, ._ },
                                    .{ ._, ._l, .sh, .tmp8q, .tmp7b, ._, ._ },
                                    .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 1), ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111111), ._, ._ },
                                    .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp6d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memid(.dst0q, .tmp6, -8), .tmp2q, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                    .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111111), ._, ._ },
                                    .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1d, .ui(6), ._, ._ },
                                    .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp1), .tmp2q, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .@"64bit", .sse2, null, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                    .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none } },
                                },
                                .call_frame = .{ .alignment = .@"16" },
                                .extra_temps = .{
                                    .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                    .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                    .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .u8, .kind = .{ .reg = .cl } },
                                    .{ .type = .u64, .kind = .{ .reg = .rdx } },
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .mem, .unused },
                                .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                    .{ .@"0:", ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, ._dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                                    .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp6d, .tmp6d, ._, ._ },
                                    .{ ._, .fromCond(cc), .set, .tmp8b, ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp7d, .tmp1d, ._, ._ },
                                    .{ ._, ._l, .sh, .tmp8q, .tmp7b, ._, ._ },
                                    .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ },
                                    .{ ._, ._c, .in, .tmp1d, ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111111), ._, ._ },
                                    .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp6d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memid(.dst0q, .tmp6, -8), .tmp2q, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                    .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111111), ._, ._ },
                                    .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1d, .ui(6), ._, ._ },
                                    .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp1), .tmp2q, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .@"64bit", .sse, .slow_incdec, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                    .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none } },
                                },
                                .call_frame = .{ .alignment = .@"16" },
                                .extra_temps = .{
                                    .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                    .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                    .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .u8, .kind = .{ .reg = .cl } },
                                    .{ .type = .u64, .kind = .{ .reg = .rdx } },
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .mem, .unused },
                                .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                    .{ .@"0:", ._ps, .mova, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, ._ps, .mova, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                                    .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp6d, .tmp6d, ._, ._ },
                                    .{ ._, .fromCond(cc), .set, .tmp8b, ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp7d, .tmp1d, ._, ._ },
                                    .{ ._, ._l, .sh, .tmp8q, .tmp7b, ._, ._ },
                                    .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 1), ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111111), ._, ._ },
                                    .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp6d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memid(.dst0q, .tmp6, -8), .tmp2q, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                    .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111111), ._, ._ },
                                    .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1d, .ui(6), ._, ._ },
                                    .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp1), .tmp2q, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .@"64bit", .sse, null, null },
                                .src_constraints = .{
                                    .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                    .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                    .any,
                                },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .to_mem, .none } },
                                },
                                .call_frame = .{ .alignment = .@"16" },
                                .extra_temps = .{
                                    .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                    .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                    .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                    .{ .type = .u8, .kind = .{ .reg = .cl } },
                                    .{ .type = .u64, .kind = .{ .reg = .rdx } },
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .mem, .unused },
                                .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                    .{ .@"0:", ._ps, .mova, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, ._ps, .mova, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                                    .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp6d, .tmp6d, ._, ._ },
                                    .{ ._, .fromCond(cc), .set, .tmp8b, ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp7d, .tmp1d, ._, ._ },
                                    .{ ._, ._l, .sh, .tmp8q, .tmp7b, ._, ._ },
                                    .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ },
                                    .{ ._, ._c, .in, .tmp1d, ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111111), ._, ._ },
                                    .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp6d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memid(.dst0q, .tmp6, -8), .tmp2q, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                    .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111111), ._, ._ },
                                    .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1d, .ui(6), ._, ._ },
                                    .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp1), .tmp2q, ._, ._ },
                                } },
                            } },
                        });
                    },
                    .eq, .neq => |cmp_op| cg.select(&res, &.{ty_pl.ty.toType()}, &ops, switch (@as(Condition, switch (cmp_op) {
                        else => unreachable,
                        .eq => .e,
                        .neq => .ne,
                    })) {
                        else => unreachable,
                        inline .e, .ne => |cc| comptime &.{ .{
                            .src_constraints = .{ .{ .bool_vec = .byte }, .{ .bool_vec = .byte }, .any },
                            .patterns = &.{
                                .{ .src = .{ .mut_mem, .imm8, .none } },
                                .{ .src = .{ .imm8, .mut_mem, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_mut_gpr, .imm8, .none } },
                                .{ .src = .{ .imm8, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .mut_mem, .to_gpr, .none } },
                                .{ .src = .{ .to_gpr, .mut_mem, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_mut_gpr, .mem, .none } },
                                .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                            },
                            .dst_temps = .{ .{ .ref = .src0 }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = switch (cc) {
                                else => unreachable,
                                .e => &.{
                                    .{ ._, ._, .xor, .dst0b, .src1b, ._, ._ },
                                    .{ ._, ._, .not, .dst0b, ._, ._, ._ },
                                },
                                .ne => &.{
                                    .{ ._, ._, .xor, .dst0b, .src1b, ._, ._ },
                                },
                            } },
                        }, .{
                            .src_constraints = .{ .{ .bool_vec = .word }, .{ .bool_vec = .word }, .any },
                            .patterns = &.{
                                .{ .src = .{ .mut_mem, .imm16, .none } },
                                .{ .src = .{ .imm16, .mut_mem, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_mut_gpr, .imm16, .none } },
                                .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .mut_mem, .to_gpr, .none } },
                                .{ .src = .{ .to_gpr, .mut_mem, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_mut_gpr, .mem, .none } },
                                .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                            },
                            .dst_temps = .{ .{ .ref = .src0 }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = switch (cc) {
                                else => unreachable,
                                .e => &.{
                                    .{ ._, ._, .xor, .dst0w, .src1w, ._, ._ },
                                    .{ ._, ._, .not, .dst0w, ._, ._, ._ },
                                },
                                .ne => &.{
                                    .{ ._, ._, .xor, .dst0w, .src1w, ._, ._ },
                                },
                            } },
                        }, .{
                            .src_constraints = .{ .{ .bool_vec = .dword }, .{ .bool_vec = .dword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .mut_mem, .imm32, .none } },
                                .{ .src = .{ .imm32, .mut_mem, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_mut_gpr, .imm32, .none } },
                                .{ .src = .{ .imm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .mut_mem, .to_gpr, .none } },
                                .{ .src = .{ .to_gpr, .mut_mem, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_mut_gpr, .mem, .none } },
                                .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                            },
                            .dst_temps = .{ .{ .ref = .src0 }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = switch (cc) {
                                else => unreachable,
                                .e => &.{
                                    .{ ._, ._, .xor, .dst0d, .src1d, ._, ._ },
                                    .{ ._, ._, .not, .dst0d, ._, ._, ._ },
                                },
                                .ne => &.{
                                    .{ ._, ._, .xor, .dst0d, .src1d, ._, ._ },
                                },
                            } },
                        }, .{
                            .required_features = .{ .@"64bit", null, null, null },
                            .src_constraints = .{ .{ .bool_vec = .qword }, .{ .bool_vec = .qword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .mut_mem, .simm32, .none } },
                                .{ .src = .{ .simm32, .mut_mem, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_mut_gpr, .simm32, .none } },
                                .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .mut_mem, .to_gpr, .none } },
                                .{ .src = .{ .to_gpr, .mut_mem, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_mut_gpr, .mem, .none } },
                                .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
                            },
                            .dst_temps = .{ .{ .ref = .src0 }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = switch (cc) {
                                else => unreachable,
                                .e => &.{
                                    .{ ._, ._, .xor, .dst0q, .src1q, ._, ._ },
                                    .{ ._, ._, .not, .dst0q, ._, ._, ._ },
                                },
                                .ne => &.{
                                    .{ ._, ._, .xor, .dst0q, .src1q, ._, ._ },
                                },
                            } },
                        }, .{
                            .src_constraints = .{ .any_bool_vec, .any_bool_vec, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = switch (cc) {
                                else => unreachable,
                                .e => &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ .@"0:", ._, .mov, .tmp1p, .memia(.src0p, .tmp0, .add_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1p, .memia(.src1p, .tmp0, .add_size), ._, ._ },
                                    .{ ._, ._, .not, .tmp1p, ._, ._, ._ },
                                    .{ ._, ._, .mov, .memia(.dst0p, .tmp0, .add_size), .tmp1p, ._, ._ },
                                    .{ ._, ._, .add, .tmp0p, .sa(.tmp1, .add_size), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                },
                                .ne => &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ .@"0:", ._, .mov, .tmp1p, .memia(.src0p, .tmp0, .add_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1p, .memia(.src1p, .tmp0, .add_size), ._, ._ },
                                    .{ ._, ._, .mov, .memia(.dst0p, .tmp0, .add_size), .tmp1p, ._, ._ },
                                    .{ ._, ._, .add, .tmp0p, .sa(.tmp1, .add_size), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .src_constraints = .{
                                .{ .scalar_int = .{ .of = .xword, .is = .byte } },
                                .{ .scalar_int = .{ .of = .xword, .is = .byte } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .mem, .none } },
                                .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_sse, .to_sse, .none } },
                            },
                            .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{
                                .kind = .all,
                                .inverted = switch (cc) {
                                    else => unreachable,
                                    .e => false,
                                    .ne => true,
                                },
                                .scalar = .byte,
                            } } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .vp_b, .cmpeq, .dst0x, .src0x, .src1x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .src_constraints = .{
                                .{ .scalar_int = .{ .of = .xword, .is = .word } },
                                .{ .scalar_int = .{ .of = .xword, .is = .word } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .mem, .none } },
                                .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_sse, .to_sse, .none } },
                            },
                            .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{
                                .kind = .all,
                                .inverted = switch (cc) {
                                    else => unreachable,
                                    .e => false,
                                    .ne => true,
                                },
                                .scalar = .word,
                            } } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .vp_w, .cmpeq, .dst0x, .src0x, .src1x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .src_constraints = .{
                                .{ .scalar_int = .{ .of = .xword, .is = .dword } },
                                .{ .scalar_int = .{ .of = .xword, .is = .dword } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .mem, .none } },
                                .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_sse, .to_sse, .none } },
                            },
                            .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{
                                .kind = .all,
                                .inverted = switch (cc) {
                                    else => unreachable,
                                    .e => false,
                                    .ne => true,
                                },
                                .scalar = .dword,
                            } } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .vp_d, .cmpeq, .dst0x, .src0x, .src1x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .src_constraints = .{
                                .{ .scalar_int = .{ .of = .xword, .is = .qword } },
                                .{ .scalar_int = .{ .of = .xword, .is = .qword } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .mem, .none } },
                                .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_sse, .to_sse, .none } },
                            },
                            .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{
                                .kind = .all,
                                .inverted = switch (cc) {
                                    else => unreachable,
                                    .e => false,
                                    .ne => true,
                                },
                                .scalar = .qword,
                            } } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .vp_q, .cmpeq, .dst0x, .src0x, .src1x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse2, null, null, null },
                            .src_constraints = .{
                                .{ .scalar_int = .{ .of = .xword, .is = .byte } },
                                .{ .scalar_int = .{ .of = .xword, .is = .byte } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mut_sse, .mem, .none } },
                                .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                            },
                            .dst_temps = .{ .{ .ref_mask = .{ .ref = .src0, .info = .{
                                .kind = .all,
                                .inverted = switch (cc) {
                                    else => unreachable,
                                    .e => false,
                                    .ne => true,
                                },
                                .scalar = .byte,
                            } } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .p_b, .cmpeq, .dst0x, .src1x, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse2, null, null, null },
                            .src_constraints = .{
                                .{ .scalar_int = .{ .of = .xword, .is = .word } },
                                .{ .scalar_int = .{ .of = .xword, .is = .word } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mut_sse, .mem, .none } },
                                .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                            },
                            .dst_temps = .{ .{ .ref_mask = .{ .ref = .src0, .info = .{
                                .kind = .all,
                                .inverted = switch (cc) {
                                    else => unreachable,
                                    .e => false,
                                    .ne => true,
                                },
                                .scalar = .word,
                            } } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .p_w, .cmpeq, .dst0x, .src1x, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse2, null, null, null },
                            .src_constraints = .{
                                .{ .scalar_int = .{ .of = .xword, .is = .dword } },
                                .{ .scalar_int = .{ .of = .xword, .is = .dword } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mut_sse, .mem, .none } },
                                .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                            },
                            .dst_temps = .{ .{ .ref_mask = .{ .ref = .src0, .info = .{
                                .kind = .all,
                                .inverted = switch (cc) {
                                    else => unreachable,
                                    .e => false,
                                    .ne => true,
                                },
                                .scalar = .dword,
                            } } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .p_d, .cmpeq, .dst0x, .src1x, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse4_1, null, null, null },
                            .src_constraints = .{
                                .{ .scalar_int = .{ .of = .xword, .is = .qword } },
                                .{ .scalar_int = .{ .of = .xword, .is = .qword } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mut_sse, .mem, .none } },
                                .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                            },
                            .dst_temps = .{ .{ .ref_mask = .{ .ref = .src0, .info = .{
                                .kind = .all,
                                .inverted = switch (cc) {
                                    else => unreachable,
                                    .e => false,
                                    .ne => true,
                                },
                                .scalar = .qword,
                            } } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .p_q, .cmpeq, .dst0x, .src1x, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .mmx, null, null, null },
                            .src_constraints = .{
                                .{ .scalar_int = .{ .of = .qword, .is = .byte } },
                                .{ .scalar_int = .{ .of = .qword, .is = .byte } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mut_mmx, .mem, .none } },
                                .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_mut_mmx, .to_mmx, .none } },
                            },
                            .dst_temps = .{ .{ .ref_mask = .{ .ref = .src0, .info = .{
                                .kind = .all,
                                .inverted = switch (cc) {
                                    else => unreachable,
                                    .e => false,
                                    .ne => true,
                                },
                                .scalar = .byte,
                            } } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .p_b, .cmpeq, .dst0q, .src1q, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .mmx, null, null, null },
                            .src_constraints = .{
                                .{ .scalar_int = .{ .of = .qword, .is = .word } },
                                .{ .scalar_int = .{ .of = .qword, .is = .word } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mut_mmx, .mem, .none } },
                                .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_mut_mmx, .to_mmx, .none } },
                            },
                            .dst_temps = .{ .{ .ref_mask = .{ .ref = .src0, .info = .{
                                .kind = .all,
                                .inverted = switch (cc) {
                                    else => unreachable,
                                    .e => false,
                                    .ne => true,
                                },
                                .scalar = .word,
                            } } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .p_w, .cmpeq, .dst0q, .src1q, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .mmx, null, null, null },
                            .src_constraints = .{
                                .{ .scalar_int = .{ .of = .qword, .is = .dword } },
                                .{ .scalar_int = .{ .of = .qword, .is = .dword } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mut_mmx, .mem, .none } },
                                .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_mut_mmx, .to_mmx, .none } },
                            },
                            .dst_temps = .{ .{ .ref_mask = .{ .ref = .src0, .info = .{
                                .kind = .all,
                                .inverted = switch (cc) {
                                    else => unreachable,
                                    .e => false,
                                    .ne => true,
                                },
                                .scalar = .dword,
                            } } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .p_d, .cmpeq, .dst0q, .src1q, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx2, null, null, null },
                            .src_constraints = .{
                                .{ .scalar_int = .{ .of = .yword, .is = .byte } },
                                .{ .scalar_int = .{ .of = .yword, .is = .byte } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .mem, .none } },
                                .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_sse, .to_sse, .none } },
                            },
                            .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{
                                .kind = .all,
                                .inverted = switch (cc) {
                                    else => unreachable,
                                    .e => false,
                                    .ne => true,
                                },
                                .scalar = .byte,
                            } } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .vp_b, .cmpeq, .dst0y, .src0y, .src1y, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx2, null, null, null },
                            .src_constraints = .{
                                .{ .scalar_int = .{ .of = .yword, .is = .word } },
                                .{ .scalar_int = .{ .of = .yword, .is = .word } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .mem, .none } },
                                .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_sse, .to_sse, .none } },
                            },
                            .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{
                                .kind = .all,
                                .inverted = switch (cc) {
                                    else => unreachable,
                                    .e => false,
                                    .ne => true,
                                },
                                .scalar = .word,
                            } } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .vp_w, .cmpeq, .dst0y, .src0y, .src1y, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx2, null, null, null },
                            .src_constraints = .{
                                .{ .scalar_int = .{ .of = .yword, .is = .dword } },
                                .{ .scalar_int = .{ .of = .yword, .is = .dword } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .mem, .none } },
                                .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_sse, .to_sse, .none } },
                            },
                            .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{
                                .kind = .all,
                                .inverted = switch (cc) {
                                    else => unreachable,
                                    .e => false,
                                    .ne => true,
                                },
                                .scalar = .dword,
                            } } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .vp_d, .cmpeq, .dst0y, .src0y, .src1y, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx2, null, null, null },
                            .src_constraints = .{
                                .{ .scalar_int = .{ .of = .yword, .is = .qword } },
                                .{ .scalar_int = .{ .of = .yword, .is = .qword } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .mem, .none } },
                                .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_sse, .to_sse, .none } },
                            },
                            .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{
                                .kind = .all,
                                .inverted = switch (cc) {
                                    else => unreachable,
                                    .e => false,
                                    .ne => true,
                                },
                                .scalar = .qword,
                            } } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .vp_q, .cmpeq, .dst0y, .src0y, .src1y, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx2, null, null, null },
                            .src_constraints = .{ .{ .scalar_int_is = .byte }, .{ .scalar_int_is = .byte }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = switch (cc) {
                                else => unreachable,
                                .e => &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ .@"0:", .v_dqu, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .vp_b, .cmpeq, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_size), ._ },
                                    .{ ._, .vp_b, .movmsk, .tmp2d, .tmp3y, ._, ._ },
                                    .{ ._, ._, .mov, .memi(.dst0d, .tmp1), .tmp2d, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 4), ._, ._ },
                                    .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                },
                                .ne => &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ .@"0:", .v_dqu, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .vp_b, .cmpeq, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_size), ._ },
                                    .{ ._, .vp_b, .movmsk, .tmp2d, .tmp3y, ._, ._ },
                                    .{ ._, ._, .not, .tmp2d, ._, ._, ._ },
                                    .{ ._, ._, .mov, .memi(.dst0d, .tmp1), .tmp2d, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 4), ._, ._ },
                                    .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                },
                            } },
                        }, .{
                            .required_features = .{ .avx2, null, null, null },
                            .src_constraints = .{ .{ .scalar_int_is = .word }, .{ .scalar_int_is = .word }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                                .{ .kind = .{ .rc = .sse } },
                                .{ .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = switch (cc) {
                                else => unreachable,
                                .e => &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ .@"0:", .v_dqu, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .vp_w, .cmpeq, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_size), ._ },
                                    .{ ._, .v_i128, .extract, .tmp4x, .tmp3y, .ui(1), ._ },
                                    .{ ._, .vp_b, .ackssw, .tmp3x, .tmp3x, .tmp4x, ._ },
                                    .{ ._, .vp_b, .movmsk, .tmp2d, .tmp3x, ._, ._ },
                                    .{ ._, ._, .mov, .memi(.dst0w, .tmp1), .tmp2w, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 2), ._, ._ },
                                    .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                },
                                .ne => &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ .@"0:", .v_dqu, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .vp_w, .cmpeq, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_size), ._ },
                                    .{ ._, .v_i128, .extract, .tmp4x, .tmp3y, .ui(1), ._ },
                                    .{ ._, .vp_b, .ackssw, .tmp3x, .tmp3x, .tmp4x, ._ },
                                    .{ ._, .vp_b, .movmsk, .tmp2d, .tmp3x, ._, ._ },
                                    .{ ._, ._, .not, .tmp2d, ._, ._, ._ },
                                    .{ ._, ._, .mov, .memi(.dst0w, .tmp1), .tmp2w, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 2), ._, ._ },
                                    .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                },
                            } },
                        }, .{
                            .required_features = .{ .avx2, null, null, null },
                            .src_constraints = .{ .{ .scalar_int_is = .dword }, .{ .scalar_int_is = .dword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .{ .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = switch (cc) {
                                else => unreachable,
                                .e => &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ .@"0:", .v_dqu, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .vp_d, .cmpeq, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_size), ._ },
                                    .{ ._, .v_ps, .movmsk, .tmp2d, .tmp3y, ._, ._ },
                                    .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 1), ._, ._ },
                                    .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                },
                                .ne => &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ .@"0:", .v_dqu, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .vp_d, .cmpeq, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_size), ._ },
                                    .{ ._, .v_ps, .movmsk, .tmp2d, .tmp3y, ._, ._ },
                                    .{ ._, ._, .not, .tmp2b, ._, ._, ._ },
                                    .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 1), ._, ._ },
                                    .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                },
                            } },
                        }, .{
                            .required_features = .{ .avx2, null, null, null },
                            .src_constraints = .{ .{ .scalar_int_is = .qword }, .{ .scalar_int_is = .qword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .reg = .rcx } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .{ .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = switch (cc) {
                                else => unreachable,
                                .e => &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ },
                                    .{ .@"0:", .v_dqu, .mov, .tmp4y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .vp_q, .cmpeq, .tmp4y, .tmp4y, .memia(.src1y, .tmp0, .add_size), ._ },
                                    .{ ._, .v_pd, .movmsk, .tmp3d, .tmp4y, ._, ._ },
                                    .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ },
                                    .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 4), ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp3d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ },
                                    .{ .@"1:", ._, .add, .tmp0p, .si(32), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ },
                                },
                                .ne => &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ },
                                    .{ .@"0:", .v_dqu, .mov, .tmp4y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .vp_q, .cmpeq, .tmp4y, .tmp4y, .memia(.src1y, .tmp0, .add_size), ._ },
                                    .{ ._, .v_pd, .movmsk, .tmp3d, .tmp4y, ._, ._ },
                                    .{ ._, ._, .xor, .tmp3b, .si(0b1111), ._, ._ },
                                    .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ },
                                    .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 4), ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp3d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ },
                                    .{ .@"1:", ._, .add, .tmp0p, .si(32), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ },
                                },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .src_constraints = .{ .{ .scalar_int_is = .byte }, .{ .scalar_int_is = .byte }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                                .{ .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = switch (cc) {
                                else => unreachable,
                                .e => &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ .@"0:", .v_dqu, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .vp_b, .cmpeq, .tmp3x, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._ },
                                    .{ ._, .vp_b, .movmsk, .tmp2d, .tmp3x, ._, ._ },
                                    .{ ._, ._, .mov, .memi(.dst0w, .tmp1), .tmp2w, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 2), ._, ._ },
                                    .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                },
                                .ne => &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ .@"0:", .v_dqu, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .vp_b, .cmpeq, .tmp3x, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._ },
                                    .{ ._, .vp_b, .movmsk, .tmp2d, .tmp3x, ._, ._ },
                                    .{ ._, ._, .not, .tmp2d, ._, ._, ._ },
                                    .{ ._, ._, .mov, .memi(.dst0w, .tmp1), .tmp2w, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 2), ._, ._ },
                                    .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .src_constraints = .{ .{ .scalar_int_is = .word }, .{ .scalar_int_is = .word }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .{ .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = switch (cc) {
                                else => unreachable,
                                .e => &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ .@"0:", .v_dqu, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .vp_w, .cmpeq, .tmp3x, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._ },
                                    .{ ._, .vp_b, .ackssw, .tmp3x, .tmp3x, .tmp3x, ._ },
                                    .{ ._, .vp_b, .movmsk, .tmp2d, .tmp3x, ._, ._ },
                                    .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 1), ._, ._ },
                                    .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                },
                                .ne => &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ .@"0:", .v_dqu, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .vp_w, .cmpeq, .tmp3x, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._ },
                                    .{ ._, .vp_b, .ackssw, .tmp3x, .tmp3x, .tmp3x, ._ },
                                    .{ ._, .vp_b, .movmsk, .tmp2d, .tmp3x, ._, ._ },
                                    .{ ._, ._, .not, .tmp2b, ._, ._, ._ },
                                    .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 1), ._, ._ },
                                    .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .src_constraints = .{ .{ .scalar_int_is = .dword }, .{ .scalar_int_is = .dword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .reg = .rcx } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .{ .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = switch (cc) {
                                else => unreachable,
                                .e => &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ },
                                    .{ .@"0:", .v_dqu, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .vp_d, .cmpeq, .tmp4x, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._ },
                                    .{ ._, .v_ps, .movmsk, .tmp3d, .tmp4x, ._, ._ },
                                    .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ },
                                    .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 4), ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp3d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ },
                                    .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ },
                                },
                                .ne => &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ },
                                    .{ .@"0:", .v_dqu, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .vp_d, .cmpeq, .tmp4x, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._ },
                                    .{ ._, .v_ps, .movmsk, .tmp3d, .tmp4x, ._, ._ },
                                    .{ ._, ._, .xor, .tmp3b, .si(0b1111), ._, ._ },
                                    .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ },
                                    .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 4), ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp3d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ },
                                    .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ },
                                },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .src_constraints = .{ .{ .scalar_int_is = .qword }, .{ .scalar_int_is = .qword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .reg = .rcx } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .{ .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = switch (cc) {
                                else => unreachable,
                                .e => &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ },
                                    .{ .@"0:", .v_dqu, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .vp_q, .cmpeq, .tmp4x, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._ },
                                    .{ ._, .v_pd, .movmsk, .tmp3d, .tmp4x, ._, ._ },
                                    .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ },
                                    .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 2), ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp3d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ },
                                    .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ },
                                },
                                .ne => &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ },
                                    .{ .@"0:", .v_dqu, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .vp_q, .cmpeq, .tmp4x, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._ },
                                    .{ ._, .v_pd, .movmsk, .tmp3d, .tmp4x, ._, ._ },
                                    .{ ._, ._, .xor, .tmp3b, .si(0b11), ._, ._ },
                                    .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ },
                                    .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 2), ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp3d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ },
                                    .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ },
                                },
                            } },
                        }, .{
                            .required_features = .{ .sse2, null, null, null },
                            .src_constraints = .{ .{ .scalar_int_is = .byte }, .{ .scalar_int_is = .byte }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                                .{ .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = switch (cc) {
                                else => unreachable,
                                .e => &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ .@"0:", ._dqu, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .p_b, .cmpeq, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .p_b, .movmsk, .tmp2d, .tmp3x, ._, ._ },
                                    .{ ._, ._, .mov, .memi(.dst0w, .tmp1), .tmp2w, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 2), ._, ._ },
                                    .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                },
                                .ne => &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ .@"0:", ._dqu, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .p_b, .cmpeq, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .p_b, .movmsk, .tmp2d, .tmp3x, ._, ._ },
                                    .{ ._, ._, .not, .tmp2d, ._, ._, ._ },
                                    .{ ._, ._, .mov, .memi(.dst0w, .tmp1), .tmp2w, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 2), ._, ._ },
                                    .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                },
                            } },
                        }, .{
                            .required_features = .{ .sse2, null, null, null },
                            .src_constraints = .{ .{ .scalar_int_is = .word }, .{ .scalar_int_is = .word }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .{ .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = switch (cc) {
                                else => unreachable,
                                .e => &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ .@"0:", ._dqu, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .p_w, .cmpeq, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .p_b, .ackssw, .tmp3x, .tmp3x, ._, ._ },
                                    .{ ._, .p_b, .movmsk, .tmp2d, .tmp3x, ._, ._ },
                                    .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 1), ._, ._ },
                                    .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                },
                                .ne => &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ .@"0:", ._dqu, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .p_w, .cmpeq, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .p_b, .ackssw, .tmp3x, .tmp3x, ._, ._ },
                                    .{ ._, .p_b, .movmsk, .tmp2d, .tmp3x, ._, ._ },
                                    .{ ._, ._, .not, .tmp2b, ._, ._, ._ },
                                    .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 1), ._, ._ },
                                    .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                },
                            } },
                        }, .{
                            .required_features = .{ .sse2, null, null, null },
                            .src_constraints = .{ .{ .scalar_int_is = .dword }, .{ .scalar_int_is = .dword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .reg = .rcx } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .{ .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = switch (cc) {
                                else => unreachable,
                                .e => &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ },
                                    .{ .@"0:", ._dqu, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .p_d, .cmpeq, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, ._ps, .movmsk, .tmp3d, .tmp4x, ._, ._ },
                                    .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ },
                                    .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 4), ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp3d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ },
                                    .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ },
                                },
                                .ne => &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ },
                                    .{ .@"0:", ._dqu, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .p_d, .cmpeq, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, ._ps, .movmsk, .tmp3d, .tmp4x, ._, ._ },
                                    .{ ._, ._, .xor, .tmp3b, .si(0b1111), ._, ._ },
                                    .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ },
                                    .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 4), ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp3d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ },
                                    .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ },
                                },
                            } },
                        }, .{
                            .required_features = .{ .sse4_1, null, null, null },
                            .src_constraints = .{ .{ .scalar_int_is = .qword }, .{ .scalar_int_is = .qword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .reg = .rcx } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .{ .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = switch (cc) {
                                else => unreachable,
                                .e => &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ },
                                    .{ .@"0:", ._dqu, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .p_q, .cmpeq, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, ._pd, .movmsk, .tmp3d, .tmp4x, ._, ._ },
                                    .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ },
                                    .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 2), ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp3d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ },
                                    .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ },
                                },
                                .ne => &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ },
                                    .{ .@"0:", ._dqu, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .p_q, .cmpeq, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                                    .{ ._, ._pd, .movmsk, .tmp3d, .tmp4x, ._, ._ },
                                    .{ ._, ._, .xor, .tmp3b, .si(0b11), ._, ._ },
                                    .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ },
                                    .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 2), ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp3d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ },
                                    .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ },
                                },
                            } },
                        }, .{
                            .required_features = .{ .sse, .mmx, null, null },
                            .src_constraints = .{ .{ .scalar_int_is = .byte }, .{ .scalar_int_is = .byte }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .{ .kind = .{ .rc = .mmx } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = switch (cc) {
                                else => unreachable,
                                .e => &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ .@"0:", ._q, .mov, .tmp3q, .memia(.src0q, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .p_b, .cmpeq, .tmp3q, .memia(.src1q, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .p_b, .movmsk, .tmp2d, .tmp3q, ._, ._ },
                                    .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 1), ._, ._ },
                                    .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                },
                                .ne => &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ .@"0:", ._q, .mov, .tmp3q, .memia(.src0q, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .p_b, .cmpeq, .tmp3q, .memia(.src1q, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .p_b, .movmsk, .tmp2d, .tmp3q, ._, ._ },
                                    .{ ._, ._, .not, .tmp2b, ._, ._, ._ },
                                    .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 1), ._, ._ },
                                    .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                },
                            } },
                        }, .{
                            .required_features = .{ .sse, .mmx, null, null },
                            .src_constraints = .{ .{ .scalar_int_is = .word }, .{ .scalar_int_is = .word }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .{ .kind = .{ .rc = .mmx } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .{ .kind = .{ .rc = .mmx } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = switch (cc) {
                                else => unreachable,
                                .e => &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ },
                                    .{ ._, .p_, .xor, .tmp3q, .tmp3q, ._, ._ },
                                    .{ .@"0:", ._q, .mov, .tmp5q, .memia(.src0q, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .p_w, .cmpeq, .tmp5q, .memia(.src1q, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .p_b, .ackssw, .tmp5q, .tmp3q, ._, ._ },
                                    .{ ._, .p_b, .movmsk, .tmp4d, .tmp5q, ._, ._ },
                                    .{ ._, ._l, .ro, .tmp4b, .tmp1b, ._, ._ },
                                    .{ ._, ._, .@"or", .tmp2b, .tmp4b, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 4), ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp4d, .tmp1d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp4d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memid(.dst0b, .tmp4, -1), .tmp2b, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ },
                                    .{ .@"1:", ._, .add, .tmp0p, .si(8), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ },
                                },
                                .ne => &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ },
                                    .{ ._, .p_, .xor, .tmp3q, .tmp3q, ._, ._ },
                                    .{ .@"0:", ._q, .mov, .tmp5q, .memia(.src0q, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .p_w, .cmpeq, .tmp5q, .memia(.src1q, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .p_b, .ackssw, .tmp5q, .tmp3q, ._, ._ },
                                    .{ ._, .p_b, .movmsk, .tmp4d, .tmp5q, ._, ._ },
                                    .{ ._, ._, .xor, .tmp4b, .si(0b1111), ._, ._ },
                                    .{ ._, ._l, .ro, .tmp4b, .tmp1b, ._, ._ },
                                    .{ ._, ._, .@"or", .tmp2b, .tmp4b, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 4), ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp4d, .tmp1d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp4d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memid(.dst0b, .tmp4, -1), .tmp2b, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ },
                                    .{ .@"1:", ._, .add, .tmp0p, .si(8), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ },
                                },
                            } },
                        }, .{
                            .required_features = .{ .sse, .mmx, null, null },
                            .src_constraints = .{ .{ .scalar_int_is = .dword }, .{ .scalar_int_is = .dword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .reg = .rcx } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .{ .kind = .{ .rc = .mmx } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .{ .kind = .{ .rc = .mmx } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = switch (cc) {
                                else => unreachable,
                                .e => &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ },
                                    .{ ._, .p_, .xor, .tmp3q, .tmp3q, ._, ._ },
                                    .{ .@"0:", ._q, .mov, .tmp5q, .memia(.src0q, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .p_d, .cmpeq, .tmp5q, .memia(.src1q, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .p_w, .ackssd, .tmp5q, .tmp3q, ._, ._ },
                                    .{ ._, .p_b, .ackssw, .tmp5q, .tmp3q, ._, ._ },
                                    .{ ._, .p_b, .movmsk, .tmp4d, .tmp5q, ._, ._ },
                                    .{ ._, ._l, .ro, .tmp4b, .tmp1b, ._, ._ },
                                    .{ ._, ._, .@"or", .tmp2b, .tmp4b, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 2), ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp4d, .tmp1d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp4d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memid(.dst0b, .tmp4, -1), .tmp2b, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ },
                                    .{ .@"1:", ._, .add, .tmp0p, .si(8), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ },
                                },
                                .ne => &.{
                                    .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ },
                                    .{ ._, .p_, .xor, .tmp3q, .tmp3q, ._, ._ },
                                    .{ .@"0:", ._q, .mov, .tmp5q, .memia(.src0q, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .p_d, .cmpeq, .tmp5q, .memia(.src1q, .tmp0, .add_size), ._, ._ },
                                    .{ ._, .p_w, .ackssd, .tmp5q, .tmp3q, ._, ._ },
                                    .{ ._, .p_b, .ackssw, .tmp5q, .tmp3q, ._, ._ },
                                    .{ ._, .p_b, .movmsk, .tmp4d, .tmp5q, ._, ._ },
                                    .{ ._, ._, .xor, .tmp4b, .si(0b11), ._, ._ },
                                    .{ ._, ._l, .ro, .tmp4b, .tmp1b, ._, ._ },
                                    .{ ._, ._, .@"or", .tmp2b, .tmp4b, ._, ._ },
                                    .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 2), ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp4d, .tmp1d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp4d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memid(.dst0b, .tmp4, -1), .tmp2b, ._, ._ },
                                    .{ ._, ._, .xor, .tmp2b, .tmp2b, ._, ._ },
                                    .{ .@"1:", ._, .add, .tmp0p, .si(8), ._, ._ },
                                    .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                    .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                    .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1d, .ui(3), ._, ._ },
                                    .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ },
                                },
                            } },
                        }, .{
                            .src_constraints = .{ .{ .scalar_int_is = .byte }, .{ .scalar_int_is = .byte }, .any },
                            .dst_constraints = .{ .{ .bool_vec = .byte }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .reg = .cl } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .xor, .dst0b, .dst0b, ._, ._ },
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ },
                                .{ .@"0:", ._, .mov, .tmp2b, .memia(.src0b, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._, .cmp, .tmp2b, .memia(.src1b, .tmp0, .add_size), ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ },
                                .{ ._, ._l, .sh, .tmp2b, .tmp1b, ._, ._ },
                                .{ ._, ._, .@"or", .dst0b, .tmp2b, ._, ._ },
                                .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ },
                                .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .src_constraints = .{ .{ .scalar_int_is = .word }, .{ .scalar_int_is = .word }, .any },
                            .dst_constraints = .{ .{ .bool_vec = .byte }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .reg = .cl } },
                                .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .xor, .dst0b, .dst0b, ._, ._ },
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ },
                                .{ .@"0:", ._, .mov, .tmp2w, .memia(.src0w, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._, .cmp, .tmp2w, .memia(.src1w, .tmp0, .add_size), ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ },
                                .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ },
                                .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ },
                                .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ },
                                .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .src_constraints = .{ .{ .scalar_int_is = .dword }, .{ .scalar_int_is = .dword }, .any },
                            .dst_constraints = .{ .{ .bool_vec = .byte }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .reg = .cl } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .xor, .dst0b, .dst0b, ._, ._ },
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ },
                                .{ .@"0:", ._, .mov, .tmp2d, .memia(.src0d, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._, .cmp, .tmp2d, .memia(.src1d, .tmp0, .add_size), ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ },
                                .{ ._, ._l, .sh, .tmp2b, .tmp1b, ._, ._ },
                                .{ ._, ._, .@"or", .dst0b, .tmp2b, ._, ._ },
                                .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ },
                                .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .@"64bit", null, null, null },
                            .src_constraints = .{ .{ .scalar_int_is = .qword }, .{ .scalar_int_is = .qword }, .any },
                            .dst_constraints = .{ .{ .bool_vec = .byte }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .reg = .cl } },
                                .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .xor, .dst0b, .dst0b, ._, ._ },
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ },
                                .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._, .cmp, .tmp2q, .memia(.src1q, .tmp0, .add_size), ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ },
                                .{ ._, ._l, .sh, .tmp2b, .tmp1b, ._, ._ },
                                .{ ._, ._, .@"or", .dst0b, .tmp2b, ._, ._ },
                                .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ },
                                .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .src_constraints = .{ .any_scalar_int, .any_scalar_int, .any },
                            .dst_constraints = .{ .{ .bool_vec = .byte }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .reg = .cl } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .xor, .dst0b, .dst0b, ._, ._ },
                                .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                                .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ },
                                .{ .@"0:", ._, .mov, .tmp2d, .sa(.src0p, .add_elem_limbs), ._, ._ },
                                .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                                .{ .@"1:", ._, .mov, .tmp4p, .memi(.src0p, .tmp0), ._, ._ },
                                .{ ._, ._, .xor, .tmp4p, .memi(.src1p, .tmp0), ._, ._ },
                                .{ ._, ._, .@"or", .tmp3p, .tmp4p, ._, ._ },
                                .{ ._, ._, .add, .tmp0p, .sa(.tmp4, .add_size), ._, ._ },
                                .{ ._, ._, .sub, .tmp2d, .si(1), ._, ._ },
                                .{ ._, ._a, .j, .@"1b", ._, ._, ._ },
                                .{ ._, ._, .@"test", .tmp3p, .tmp3p, ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ },
                                .{ ._, ._l, .sh, .tmp2b, .tmp1b, ._, ._ },
                                .{ ._, ._, .@"or", .dst0b, .tmp2b, ._, ._ },
                                .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ },
                                .{ ._, ._, .cmp, .tmp1b, .sa(.dst0, .add_len), ._, ._ },
                                .{ ._, ._b, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .src_constraints = .{ .{ .scalar_int_is = .byte }, .{ .scalar_int_is = .byte }, .any },
                            .dst_constraints = .{ .{ .bool_vec = .dword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .reg = .cl } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ },
                                .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ ._, ._, .mov, .tmp3b, .memia(.src0b, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._, .cmp, .tmp3b, .memia(.src1b, .tmp0, .add_size), ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ },
                                .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ },
                                .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ },
                                .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ },
                                .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .src_constraints = .{ .{ .scalar_int_is = .word }, .{ .scalar_int_is = .word }, .any },
                            .dst_constraints = .{ .{ .bool_vec = .dword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .reg = .cl } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ },
                                .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ ._, ._, .mov, .tmp3w, .memia(.src0w, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._, .cmp, .tmp3w, .memia(.src1w, .tmp0, .add_size), ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ },
                                .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ },
                                .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ },
                                .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ },
                                .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .src_constraints = .{ .{ .scalar_int_is = .dword }, .{ .scalar_int_is = .dword }, .any },
                            .dst_constraints = .{ .{ .bool_vec = .dword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .reg = .cl } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ },
                                .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ ._, ._, .mov, .tmp3d, .memia(.src0d, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._, .cmp, .tmp3d, .memia(.src1d, .tmp0, .add_size), ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ },
                                .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ },
                                .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ },
                                .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ },
                                .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .@"64bit", null, null, null },
                            .src_constraints = .{ .{ .scalar_int_is = .qword }, .{ .scalar_int_is = .qword }, .any },
                            .dst_constraints = .{ .{ .bool_vec = .dword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .reg = .cl } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ },
                                .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ ._, ._, .mov, .tmp3q, .memia(.src0q, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._, .cmp, .tmp3q, .memia(.src1q, .tmp0, .add_size), ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ },
                                .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ },
                                .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ },
                                .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ },
                                .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .src_constraints = .{ .any_scalar_int, .any_scalar_int, .any },
                            .dst_constraints = .{ .{ .bool_vec = .dword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .reg = .cl } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                                .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                                .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ },
                                .{ .@"0:", ._, .mov, .tmp2d, .sa(.src0p, .add_elem_limbs), ._, ._ },
                                .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                                .{ .@"1:", ._, .mov, .tmp4p, .memi(.src0p, .tmp0), ._, ._ },
                                .{ ._, ._, .xor, .tmp4p, .memi(.src1p, .tmp0), ._, ._ },
                                .{ ._, ._, .@"or", .tmp3p, .tmp4p, ._, ._ },
                                .{ ._, ._, .add, .tmp0p, .sa(.tmp4, .add_size), ._, ._ },
                                .{ ._, ._, .sub, .tmp2d, .si(1), ._, ._ },
                                .{ ._, ._a, .j, .@"1b", ._, ._, ._ },
                                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ ._, ._, .@"test", .tmp3p, .tmp3p, ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ },
                                .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ },
                                .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ },
                                .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ },
                                .{ ._, ._, .cmp, .tmp1b, .sa(.dst0, .add_len), ._, ._ },
                                .{ ._, ._b, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .@"64bit", null, null, null },
                            .src_constraints = .{ .{ .scalar_int_is = .byte }, .{ .scalar_int_is = .byte }, .any },
                            .dst_constraints = .{ .{ .bool_vec = .qword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .reg = .cl } },
                                .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ },
                                .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ ._, ._, .mov, .tmp3b, .memia(.src0b, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._, .cmp, .tmp3b, .memia(.src1b, .tmp0, .add_size), ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ },
                                .{ ._, ._l, .sh, .tmp2q, .tmp1b, ._, ._ },
                                .{ ._, ._, .@"or", .dst0q, .tmp2q, ._, ._ },
                                .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ },
                                .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .@"64bit", null, null, null },
                            .src_constraints = .{ .{ .scalar_int_is = .word }, .{ .scalar_int_is = .word }, .any },
                            .dst_constraints = .{ .{ .bool_vec = .qword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .reg = .cl } },
                                .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ ._, ._, .mov, .tmp3w, .memia(.src0w, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._, .cmp, .tmp3w, .memia(.src1w, .tmp0, .add_size), ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ },
                                .{ ._, ._l, .sh, .tmp2q, .tmp1b, ._, ._ },
                                .{ ._, ._, .@"or", .dst0q, .tmp2q, ._, ._ },
                                .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ },
                                .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .@"64bit", null, null, null },
                            .src_constraints = .{ .{ .scalar_int_is = .dword }, .{ .scalar_int_is = .dword }, .any },
                            .dst_constraints = .{ .{ .bool_vec = .qword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .reg = .cl } },
                                .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ },
                                .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ ._, ._, .mov, .tmp3d, .memia(.src0d, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._, .cmp, .tmp3d, .memia(.src1d, .tmp0, .add_size), ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ },
                                .{ ._, ._l, .sh, .tmp2q, .tmp1b, ._, ._ },
                                .{ ._, ._, .@"or", .dst0q, .tmp2q, ._, ._ },
                                .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ },
                                .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .@"64bit", null, null, null },
                            .src_constraints = .{ .{ .scalar_int_is = .qword }, .{ .scalar_int_is = .qword }, .any },
                            .dst_constraints = .{ .{ .bool_vec = .qword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .reg = .cl } },
                                .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ },
                                .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ ._, ._, .mov, .tmp3q, .memia(.src0q, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._, .cmp, .tmp3q, .memia(.src1q, .tmp0, .add_size), ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ },
                                .{ ._, ._l, .sh, .tmp2q, .tmp1b, ._, ._ },
                                .{ ._, ._, .@"or", .dst0q, .tmp2q, ._, ._ },
                                .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ },
                                .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .@"64bit", null, null, null },
                            .src_constraints = .{ .any_scalar_int, .any_scalar_int, .any },
                            .dst_constraints = .{ .{ .bool_vec = .qword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .reg = .cl } },
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                                .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                                .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ },
                                .{ .@"0:", ._, .mov, .tmp2d, .sa(.src0p, .add_elem_limbs), ._, ._ },
                                .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                                .{ .@"1:", ._, .mov, .tmp4p, .memi(.src0p, .tmp0), ._, ._ },
                                .{ ._, ._, .xor, .tmp4p, .memi(.src1p, .tmp0), ._, ._ },
                                .{ ._, ._, .@"or", .tmp3p, .tmp4p, ._, ._ },
                                .{ ._, ._, .add, .tmp0p, .sa(.tmp4, .add_size), ._, ._ },
                                .{ ._, ._, .sub, .tmp2d, .si(1), ._, ._ },
                                .{ ._, ._a, .j, .@"1b", ._, ._, ._ },
                                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ ._, ._, .@"test", .tmp3p, .tmp3p, ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ },
                                .{ ._, ._l, .sh, .tmp2q, .tmp1b, ._, ._ },
                                .{ ._, ._, .@"or", .dst0q, .tmp2q, ._, ._ },
                                .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ },
                                .{ ._, ._, .cmp, .tmp1b, .sa(.dst0, .add_len), ._, ._ },
                                .{ ._, ._b, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .src_constraints = .{ .{ .scalar_int_is = .byte }, .{ .scalar_int_is = .byte }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .reg = .ecx } },
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ .@"0:", ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                                .{ ._, ._, .mov, .tmp4b, .memia(.src0b, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._, .cmp, .tmp4b, .memia(.src1b, .tmp0, .add_size), ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp3b, ._, ._, ._ },
                                .{ ._, ._l, .sh, .tmp3p, .tmp1b, ._, ._ },
                                .{ ._, ._, .@"or", .tmp2p, .tmp3p, ._, ._ },
                                .{ ._, ._, .add, .tmp1d, .si(1), ._, ._ },
                                .{ ._, ._, .@"test", .tmp1d, .sia(-1, .none, .add_ptr_bit_size), ._, ._ },
                                .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ },
                                .{ ._, ._r, .sh, .tmp3d, .ui(3), ._, ._ },
                                .{ ._, ._, .mov, .memia(.dst0p, .tmp3, .sub_ptr_size), .tmp2p, ._, ._ },
                                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ .@"1:", ._, .add, .tmp0p, .si(1), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                .{ ._, ._, .@"test", .tmp1d, .sia(-1, .none, .add_ptr_bit_size), ._, ._ },
                                .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                .{ ._, ._r, .sh, .tmp1d, .ui(6), ._, ._ },
                                .{ ._, ._, .mov, .memsi(.dst0p, .@"8", .tmp1), .tmp2p, ._, ._ },
                            } },
                        }, .{
                            .src_constraints = .{ .{ .scalar_int_is = .word }, .{ .scalar_int_is = .word }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .reg = .ecx } },
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ .@"0:", ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                                .{ ._, ._, .mov, .tmp4w, .memia(.src0w, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._, .cmp, .tmp4w, .memia(.src1w, .tmp0, .add_size), ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp3b, ._, ._, ._ },
                                .{ ._, ._l, .sh, .tmp3p, .tmp1b, ._, ._ },
                                .{ ._, ._, .@"or", .tmp2p, .tmp3p, ._, ._ },
                                .{ ._, ._, .add, .tmp1d, .si(1), ._, ._ },
                                .{ ._, ._, .@"test", .tmp1d, .sia(-1, .none, .add_ptr_bit_size), ._, ._ },
                                .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ },
                                .{ ._, ._r, .sh, .tmp3d, .ui(3), ._, ._ },
                                .{ ._, ._, .mov, .memia(.dst0p, .tmp3, .sub_ptr_size), .tmp2p, ._, ._ },
                                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ .@"1:", ._, .add, .tmp0p, .si(2), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                .{ ._, ._, .@"test", .tmp1d, .sia(-1, .none, .add_ptr_bit_size), ._, ._ },
                                .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                .{ ._, ._r, .sh, .tmp1d, .ui(6), ._, ._ },
                                .{ ._, ._, .mov, .memsi(.dst0p, .@"8", .tmp1), .tmp2p, ._, ._ },
                            } },
                        }, .{
                            .src_constraints = .{ .{ .scalar_int_is = .dword }, .{ .scalar_int_is = .dword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .reg = .ecx } },
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ .@"0:", ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                                .{ ._, ._, .mov, .tmp4d, .memia(.src0d, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._, .cmp, .tmp4d, .memia(.src1d, .tmp0, .add_size), ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp3b, ._, ._, ._ },
                                .{ ._, ._l, .sh, .tmp3p, .tmp1b, ._, ._ },
                                .{ ._, ._, .@"or", .tmp2p, .tmp3p, ._, ._ },
                                .{ ._, ._, .add, .tmp1d, .si(1), ._, ._ },
                                .{ ._, ._, .@"test", .tmp1d, .sia(-1, .none, .add_ptr_bit_size), ._, ._ },
                                .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ },
                                .{ ._, ._r, .sh, .tmp3d, .ui(3), ._, ._ },
                                .{ ._, ._, .mov, .memia(.dst0p, .tmp3, .sub_ptr_size), .tmp2p, ._, ._ },
                                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ .@"1:", ._, .add, .tmp0p, .si(4), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                .{ ._, ._, .@"test", .tmp1d, .sia(-1, .none, .add_ptr_bit_size), ._, ._ },
                                .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                .{ ._, ._r, .sh, .tmp1d, .ui(6), ._, ._ },
                                .{ ._, ._, .mov, .memsi(.dst0p, .@"8", .tmp1), .tmp2p, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .@"64bit", null, null, null },
                            .src_constraints = .{ .{ .scalar_int_is = .qword }, .{ .scalar_int_is = .qword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .reg = .ecx } },
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ .@"0:", ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                                .{ ._, ._, .mov, .tmp4q, .memia(.src0q, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._, .cmp, .tmp4q, .memia(.src1q, .tmp0, .add_size), ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp3b, ._, ._, ._ },
                                .{ ._, ._l, .sh, .tmp3p, .tmp1b, ._, ._ },
                                .{ ._, ._, .@"or", .tmp2p, .tmp3p, ._, ._ },
                                .{ ._, ._, .add, .tmp1d, .si(1), ._, ._ },
                                .{ ._, ._, .@"test", .tmp1d, .sia(-1, .none, .add_ptr_bit_size), ._, ._ },
                                .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ },
                                .{ ._, ._r, .sh, .tmp3d, .ui(3), ._, ._ },
                                .{ ._, ._, .mov, .memia(.dst0p, .tmp3, .sub_ptr_size), .tmp2p, ._, ._ },
                                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ .@"1:", ._, .add, .tmp0p, .si(8), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                .{ ._, ._, .@"test", .tmp1d, .sia(-1, .none, .add_ptr_bit_size), ._, ._ },
                                .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                .{ ._, ._r, .sh, .tmp1d, .ui(6), ._, ._ },
                                .{ ._, ._, .mov, .memsi(.dst0p, .@"8", .tmp1), .tmp2p, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .f16c, null, null, null },
                            .src_constraints = .{
                                .{ .scalar_float = .{ .of = .word, .is = .word } },
                                .{ .scalar_float = .{ .of = .word, .is = .word } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .to_sse, .none } },
                            },
                            .extra_temps = .{
                                .{ .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .mut_rc_mask = .{
                                .ref = .src0,
                                .rc = .sse,
                                .info = .{ .kind = .all, .scalar = .dword },
                            } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                                .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
                                .{ ._, .v_ss, .cmp, .dst0x, .dst0x, .tmp0d, .vp(switch (cc) {
                                    else => unreachable,
                                    .e => .eq,
                                    .ne => .neq,
                                }) },
                            } },
                        }, .{
                            .required_features = .{ .f16c, null, null, null },
                            .src_constraints = .{
                                .{ .scalar_float = .{ .of = .qword, .is = .word } },
                                .{ .scalar_float = .{ .of = .qword, .is = .word } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .mem, .mem, .none } },
                                .{ .src = .{ .sse, .mem, .none } },
                                .{ .src = .{ .mem, .sse, .none } },
                                .{ .src = .{ .to_sse, .to_sse, .none } },
                            },
                            .extra_temps = .{
                                .{ .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .mut_rc_mask = .{
                                .ref = .src0,
                                .rc = .sse,
                                .info = .{ .kind = .all, .scalar = .dword },
                            } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                                .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
                                .{ ._, .v_ps, .cmp, .dst0x, .dst0x, .tmp0x, .vp(switch (cc) {
                                    else => unreachable,
                                    .e => .eq,
                                    .ne => .neq,
                                }) },
                            } },
                        }, .{
                            .required_features = .{ .f16c, null, null, null },
                            .src_constraints = .{
                                .{ .scalar_float = .{ .of = .xword, .is = .word } },
                                .{ .scalar_float = .{ .of = .xword, .is = .word } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .mem, .mem, .none } },
                                .{ .src = .{ .to_sse, .mem, .none } },
                                .{ .src = .{ .mem, .to_sse, .none } },
                                .{ .src = .{ .to_sse, .to_sse, .none } },
                            },
                            .extra_temps = .{
                                .{ .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .mut_rc_mask = .{
                                .ref = .src0,
                                .rc = .sse,
                                .info = .{ .kind = .all, .scalar = .dword },
                            } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
                                .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ },
                                .{ ._, .v_ps, .cmp, .dst0y, .dst0y, .tmp0y, .vp(switch (cc) {
                                    else => unreachable,
                                    .e => .eq,
                                    .ne => .neq,
                                }) },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .src_constraints = .{
                                .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                                .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .mem, .none } },
                                .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_sse, .to_sse, .none } },
                            },
                            .dst_temps = .{ .{ .mut_rc_mask = .{
                                .ref = .src0,
                                .rc = .sse,
                                .info = .{ .kind = .all, .scalar = .dword },
                            } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .v_ss, .cmp, .dst0x, .src0x, .src1d, .vp(switch (cc) {
                                    else => unreachable,
                                    .e => .eq,
                                    .ne => .neq,
                                }) },
                            } },
                        }, .{
                            .required_features = .{ .sse, null, null, null },
                            .src_constraints = .{
                                .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                                .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mut_sse, .mem, .none } },
                                .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                            },
                            .dst_temps = .{ .{ .ref_mask = .{
                                .ref = .src0,
                                .info = .{ .kind = .all, .scalar = .dword },
                            } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, ._ss, .cmp, .dst0x, .src1d, .sp(switch (cc) {
                                    else => unreachable,
                                    .e => .eq,
                                    .ne => .neq,
                                }), ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .src_constraints = .{
                                .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                                .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .mem, .none } },
                                .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_sse, .to_sse, .none } },
                            },
                            .dst_temps = .{ .{ .mut_rc_mask = .{
                                .ref = .src0,
                                .rc = .sse,
                                .info = .{ .kind = .all, .scalar = .dword },
                            } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .v_ps, .cmp, .dst0x, .src0x, .src1x, .vp(switch (cc) {
                                    else => unreachable,
                                    .e => .eq,
                                    .ne => .neq,
                                }) },
                            } },
                        }, .{
                            .required_features = .{ .sse, null, null, null },
                            .src_constraints = .{
                                .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                                .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mut_sse, .mem, .none } },
                                .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                            },
                            .dst_temps = .{ .{ .ref_mask = .{
                                .ref = .src0,
                                .info = .{ .kind = .all, .scalar = .dword },
                            } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, ._ps, .cmp, .dst0x, .src1x, .sp(switch (cc) {
                                    else => unreachable,
                                    .e => .eq,
                                    .ne => .neq,
                                }), ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .src_constraints = .{
                                .{ .scalar_float = .{ .of = .yword, .is = .dword } },
                                .{ .scalar_float = .{ .of = .yword, .is = .dword } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .mem, .none } },
                                .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_sse, .to_sse, .none } },
                            },
                            .dst_temps = .{ .{ .mut_rc_mask = .{
                                .ref = .src0,
                                .rc = .sse,
                                .info = .{ .kind = .all, .scalar = .dword },
                            } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .v_ps, .cmp, .dst0y, .src0y, .src1y, .vp(switch (cc) {
                                    else => unreachable,
                                    .e => .eq,
                                    .ne => .neq,
                                }) },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .src_constraints = .{
                                .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                                .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .mem, .none } },
                                .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_sse, .to_sse, .none } },
                            },
                            .dst_temps = .{ .{ .mut_rc_mask = .{
                                .ref = .src0,
                                .rc = .sse,
                                .info = .{ .kind = .all, .scalar = .qword },
                            } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .v_sd, .cmp, .dst0x, .src0x, .src1q, .vp(switch (cc) {
                                    else => unreachable,
                                    .e => .eq,
                                    .ne => .neq,
                                }) },
                            } },
                        }, .{
                            .required_features = .{ .sse2, null, null, null },
                            .src_constraints = .{
                                .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                                .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mut_sse, .mem, .none } },
                                .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                            },
                            .dst_temps = .{ .{ .ref_mask = .{
                                .ref = .src0,
                                .info = .{ .kind = .all, .scalar = .qword },
                            } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, ._sd, .cmp, .dst0x, .src1q, .sp(switch (cc) {
                                    else => unreachable,
                                    .e => .eq,
                                    .ne => .neq,
                                }), ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .src_constraints = .{
                                .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                                .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .mem, .none } },
                                .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_sse, .to_sse, .none } },
                            },
                            .dst_temps = .{ .{ .mut_rc_mask = .{
                                .ref = .src0,
                                .rc = .sse,
                                .info = .{ .kind = .all, .scalar = .qword },
                            } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .v_pd, .cmp, .dst0x, .src0x, .src1x, .vp(switch (cc) {
                                    else => unreachable,
                                    .e => .eq,
                                    .ne => .neq,
                                }) },
                            } },
                        }, .{
                            .required_features = .{ .sse2, null, null, null },
                            .src_constraints = .{
                                .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                                .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mut_sse, .mem, .none } },
                                .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                            },
                            .dst_temps = .{ .{ .ref_mask = .{
                                .ref = .src0,
                                .info = .{ .kind = .all, .scalar = .qword },
                            } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, ._pd, .cmp, .dst0x, .src1x, .sp(switch (cc) {
                                    else => unreachable,
                                    .e => .eq,
                                    .ne => .neq,
                                }), ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .src_constraints = .{
                                .{ .scalar_float = .{ .of = .yword, .is = .qword } },
                                .{ .scalar_float = .{ .of = .yword, .is = .qword } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .mem, .none } },
                                .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                                .{ .src = .{ .to_sse, .to_sse, .none } },
                            },
                            .dst_temps = .{ .{ .mut_rc_mask = .{
                                .ref = .src0,
                                .rc = .sse,
                                .info = .{ .kind = .all, .scalar = .qword },
                            } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .v_pd, .cmp, .dst0y, .src0y, .src1y, .vp(switch (cc) {
                                    else => unreachable,
                                    .e => .eq,
                                    .ne => .neq,
                                }) },
                            } },
                        }, .{
                            .required_features = .{ .f16c, .slow_incdec, null, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
                                .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                                .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                                .{ .@"0:", .v_ps, .cvtph2, .tmp2y, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                .{ ._, .v_ps, .cvtph2, .tmp3y, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                                .{ ._, .v_ps, .cmp, .tmp2y, .tmp2y, .tmp3y, .vp(switch (cc) {
                                    else => unreachable,
                                    .e => .eq,
                                    .ne => .neq,
                                }) },
                                .{ ._, .v_ps, .movmsk, .tmp4d, .tmp2y, ._, ._ },
                                .{ ._, ._, .mov, .lea(.tmp1b), .tmp4b, ._, ._ },
                                .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 1), ._, ._ },
                                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .f16c, null, null, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
                                .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                                .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                                .{ .@"0:", .v_ps, .cvtph2, .tmp2y, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                .{ ._, .v_ps, .cvtph2, .tmp3y, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                                .{ ._, .v_ps, .cmp, .tmp2y, .tmp2y, .tmp3y, .vp(switch (cc) {
                                    else => unreachable,
                                    .e => .eq,
                                    .ne => .neq,
                                }) },
                                .{ ._, .v_ps, .movmsk, .tmp4d, .tmp2y, ._, ._ },
                                .{ ._, ._, .mov, .lea(.tmp1b), .tmp4b, ._, ._ },
                                .{ ._, ._c, .in, .tmp1p, ._, ._, ._ },
                                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, .slow_incdec, null, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                .any,
                            },
                            .dst_constraints = .{ .{ .bool_vec = .dword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .call_frame = .{ .alignment = .@"16" },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .u8, .kind = .{ .reg = .cl } },
                                .{ .type = .u32, .kind = .{ .reg = .edx } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                            .each = .{ .once = &.{
                                .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                                .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                                .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ },
                                .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memsi(.src0w, .@"2", .tmp0), .ui(0) },
                                .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memsi(.src1w, .@"2", .tmp0), .ui(0) },
                                .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                                .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                                .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp6b, ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                                .{ ._, ._l, .sh, .tmp6d, .tmp5b, ._, ._ },
                                .{ ._, ._, .@"or", .dst0d, .tmp6d, ._, ._ },
                                .{ ._, ._, .add, .tmp0d, .si(1), ._, ._ },
                                .{ ._, ._, .cmp, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                                .{ ._, ._b, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                .any,
                            },
                            .dst_constraints = .{ .{ .bool_vec = .dword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .call_frame = .{ .alignment = .@"16" },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .u8, .kind = .{ .reg = .cl } },
                                .{ .type = .u32, .kind = .{ .reg = .edx } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                            .each = .{ .once = &.{
                                .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                                .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                                .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ },
                                .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memsi(.src0w, .@"2", .tmp0), .ui(0) },
                                .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memsi(.src1w, .@"2", .tmp0), .ui(0) },
                                .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                                .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                                .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp6b, ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                                .{ ._, ._l, .sh, .tmp6d, .tmp5b, ._, ._ },
                                .{ ._, ._, .@"or", .dst0d, .tmp6d, ._, ._ },
                                .{ ._, ._c, .in, .tmp0d, ._, ._, ._ },
                                .{ ._, ._, .cmp, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                                .{ ._, ._b, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse2, .slow_incdec, null, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                .any,
                            },
                            .dst_constraints = .{ .{ .bool_vec = .dword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .call_frame = .{ .alignment = .@"16" },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .u8, .kind = .{ .reg = .cl } },
                                .{ .type = .u32, .kind = .{ .reg = .edx } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                            .each = .{ .once = &.{
                                .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                                .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                                .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                                .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
                                .{ ._, .p_w, .insr, .tmp1x, .memsi(.src0w, .@"2", .tmp0), .ui(0), ._ },
                                .{ ._, .p_w, .insr, .tmp2x, .memsi(.src1w, .@"2", .tmp0), .ui(0), ._ },
                                .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                                .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                                .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp6b, ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                                .{ ._, ._l, .sh, .tmp6d, .tmp5b, ._, ._ },
                                .{ ._, ._, .@"or", .dst0d, .tmp6d, ._, ._ },
                                .{ ._, ._, .add, .tmp0d, .si(1), ._, ._ },
                                .{ ._, ._, .cmp, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                                .{ ._, ._b, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse2, null, null, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                .any,
                            },
                            .dst_constraints = .{ .{ .bool_vec = .dword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .call_frame = .{ .alignment = .@"16" },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .u8, .kind = .{ .reg = .cl } },
                                .{ .type = .u32, .kind = .{ .reg = .edx } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                            .each = .{ .once = &.{
                                .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                                .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                                .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                                .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
                                .{ ._, .p_w, .insr, .tmp1x, .memsi(.src0w, .@"2", .tmp0), .ui(0), ._ },
                                .{ ._, .p_w, .insr, .tmp2x, .memsi(.src1w, .@"2", .tmp0), .ui(0), ._ },
                                .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                                .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                                .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp6b, ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                                .{ ._, ._l, .sh, .tmp6d, .tmp5b, ._, ._ },
                                .{ ._, ._, .@"or", .dst0d, .tmp6d, ._, ._ },
                                .{ ._, ._c, .in, .tmp0d, ._, ._, ._ },
                                .{ ._, ._, .cmp, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                                .{ ._, ._b, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse, .slow_incdec, null, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                .any,
                            },
                            .dst_constraints = .{ .{ .bool_vec = .dword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .call_frame = .{ .alignment = .@"16" },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .u8, .kind = .{ .reg = .cl } },
                                .{ .type = .u32, .kind = .{ .reg = .edx } },
                                .{ .type = .f32, .kind = .mem },
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                            .each = .{ .once = &.{
                                .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                                .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                                .{ .@"0:", ._, .movzx, .tmp4d, .memsi(.src0w, .@"2", .tmp0), ._, ._ },
                                .{ ._, ._, .mov, .mem(.tmp7d), .tmp4d, ._, ._ },
                                .{ ._, ._ss, .mov, .tmp1x, .mem(.tmp7d), ._, ._ },
                                .{ ._, ._, .movzx, .tmp4d, .memsi(.src1w, .@"2", .tmp0), ._, ._ },
                                .{ ._, ._, .mov, .mem(.tmp7d), .tmp4d, ._, ._ },
                                .{ ._, ._ss, .mov, .tmp2x, .mem(.tmp7d), ._, ._ },
                                .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                                .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                                .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp6b, ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                                .{ ._, ._l, .sh, .tmp6d, .tmp5b, ._, ._ },
                                .{ ._, ._, .@"or", .dst0d, .tmp6d, ._, ._ },
                                .{ ._, ._, .add, .tmp0d, .si(1), ._, ._ },
                                .{ ._, ._, .cmp, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                                .{ ._, ._b, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse, null, null, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                .any,
                            },
                            .dst_constraints = .{ .{ .bool_vec = .dword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .call_frame = .{ .alignment = .@"16" },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .u8, .kind = .{ .reg = .cl } },
                                .{ .type = .u32, .kind = .{ .reg = .edx } },
                                .{ .type = .f32, .kind = .mem },
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                            .each = .{ .once = &.{
                                .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                                .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                                .{ .@"0:", ._, .movzx, .tmp4d, .memsi(.src0w, .@"2", .tmp0), ._, ._ },
                                .{ ._, ._, .mov, .mem(.tmp7d), .tmp4d, ._, ._ },
                                .{ ._, ._ss, .mov, .tmp1x, .mem(.tmp7d), ._, ._ },
                                .{ ._, ._, .movzx, .tmp4d, .memsi(.src1w, .@"2", .tmp0), ._, ._ },
                                .{ ._, ._, .mov, .mem(.tmp7d), .tmp4d, ._, ._ },
                                .{ ._, ._ss, .mov, .tmp2x, .mem(.tmp7d), ._, ._ },
                                .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                                .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                                .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp6b, ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                                .{ ._, ._l, .sh, .tmp6d, .tmp5b, ._, ._ },
                                .{ ._, ._, .@"or", .dst0d, .tmp6d, ._, ._ },
                                .{ ._, ._c, .in, .tmp0d, ._, ._, ._ },
                                .{ ._, ._, .cmp, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                                .{ ._, ._b, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .@"64bit", .avx, .slow_incdec, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .call_frame = .{ .alignment = .@"16" },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .u8, .kind = .{ .reg = .cl } },
                                .{ .type = .u64, .kind = .{ .reg = .rdx } },
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                            .each = .{ .once = &.{
                                .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                                .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                .{ .@"0:", .vp_, .xor, .tmp3x, .tmp3x, .tmp3x, ._ },
                                .{ ._, .vp_w, .insr, .tmp2x, .tmp3x, .memsi(.src0w, .@"2", .tmp0), .ui(0) },
                                .{ ._, .vp_w, .insr, .tmp3x, .tmp3x, .memsi(.src1w, .@"2", .tmp0), .ui(0) },
                                .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                                .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                                .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ },
                                .{ ._, ._l, .sh, .tmp7q, .tmp6b, ._, ._ },
                                .{ ._, ._, .@"or", .tmp1q, .tmp7q, ._, ._ },
                                .{ ._, ._, .lea, .tmp0d, .lead(.tmp0, 1), ._, ._ },
                                .{ ._, ._, .@"test", .tmp0d, .si(0b111111), ._, ._ },
                                .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                                .{ ._, ._r, .sh, .tmp5d, .ui(3), ._, ._ },
                                .{ ._, ._, .mov, .memid(.dst0q, .tmp5, -8), .tmp1q, ._, ._ },
                                .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                .{ .@"1:", ._, .cmp, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                                .{ ._, ._b, .j, .@"0b", ._, ._, ._ },
                                .{ ._, ._, .@"test", .tmp0d, .si(0b111111), ._, ._ },
                                .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                                .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp1q, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .@"64bit", .avx, null, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .call_frame = .{ .alignment = .@"16" },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .u8, .kind = .{ .reg = .cl } },
                                .{ .type = .u64, .kind = .{ .reg = .rdx } },
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                            .each = .{ .once = &.{
                                .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                                .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                .{ .@"0:", .vp_, .xor, .tmp3x, .tmp3x, .tmp3x, ._ },
                                .{ ._, .vp_w, .insr, .tmp2x, .tmp3x, .memsi(.src0w, .@"2", .tmp0), .ui(0) },
                                .{ ._, .vp_w, .insr, .tmp3x, .tmp3x, .memsi(.src1w, .@"2", .tmp0), .ui(0) },
                                .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                                .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                                .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ },
                                .{ ._, ._l, .sh, .tmp7q, .tmp6b, ._, ._ },
                                .{ ._, ._, .@"or", .tmp1q, .tmp7q, ._, ._ },
                                .{ ._, ._c, .in, .tmp0d, ._, ._, ._ },
                                .{ ._, ._, .@"test", .tmp0d, .si(0b111111), ._, ._ },
                                .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                                .{ ._, ._r, .sh, .tmp5d, .ui(3), ._, ._ },
                                .{ ._, ._, .mov, .memid(.dst0q, .tmp5, -8), .tmp1q, ._, ._ },
                                .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                .{ .@"1:", ._, .cmp, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                                .{ ._, ._b, .j, .@"0b", ._, ._, ._ },
                                .{ ._, ._, .@"test", .tmp0d, .si(0b111111), ._, ._ },
                                .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                                .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp1q, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .@"64bit", .sse2, .slow_incdec, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .call_frame = .{ .alignment = .@"16" },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .u8, .kind = .{ .reg = .cl } },
                                .{ .type = .u64, .kind = .{ .reg = .rdx } },
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                            .each = .{ .once = &.{
                                .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                                .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                .{ .@"0:", .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
                                .{ ._, .p_w, .insr, .tmp2x, .memsi(.src0w, .@"2", .tmp0), .ui(0), ._ },
                                .{ ._, .p_, .xor, .tmp3x, .tmp3x, ._, ._ },
                                .{ ._, .p_w, .insr, .tmp3x, .memsi(.src1w, .@"2", .tmp0), .ui(0), ._ },
                                .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                                .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                                .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ },
                                .{ ._, ._l, .sh, .tmp7q, .tmp6b, ._, ._ },
                                .{ ._, ._, .@"or", .tmp1q, .tmp7q, ._, ._ },
                                .{ ._, ._, .lea, .tmp0d, .lead(.tmp0, 1), ._, ._ },
                                .{ ._, ._, .@"test", .tmp0d, .si(0b111111), ._, ._ },
                                .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                                .{ ._, ._r, .sh, .tmp5d, .ui(3), ._, ._ },
                                .{ ._, ._, .mov, .memid(.dst0q, .tmp5, -8), .tmp1q, ._, ._ },
                                .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                .{ .@"1:", ._, .cmp, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                                .{ ._, ._b, .j, .@"0b", ._, ._, ._ },
                                .{ ._, ._, .@"test", .tmp0d, .si(0b111111), ._, ._ },
                                .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                                .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp1q, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .@"64bit", .sse2, null, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .call_frame = .{ .alignment = .@"16" },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .u8, .kind = .{ .reg = .cl } },
                                .{ .type = .u64, .kind = .{ .reg = .rdx } },
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                            .each = .{ .once = &.{
                                .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                                .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                .{ .@"0:", .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
                                .{ ._, .p_w, .insr, .tmp2x, .memsi(.src0w, .@"2", .tmp0), .ui(0), ._ },
                                .{ ._, .p_, .xor, .tmp3x, .tmp3x, ._, ._ },
                                .{ ._, .p_w, .insr, .tmp3x, .memsi(.src1w, .@"2", .tmp0), .ui(0), ._ },
                                .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                                .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                                .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ },
                                .{ ._, ._l, .sh, .tmp7q, .tmp6b, ._, ._ },
                                .{ ._, ._, .@"or", .tmp1q, .tmp7q, ._, ._ },
                                .{ ._, ._c, .in, .tmp0d, ._, ._, ._ },
                                .{ ._, ._, .@"test", .tmp0d, .si(0b111111), ._, ._ },
                                .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                                .{ ._, ._r, .sh, .tmp5d, .ui(3), ._, ._ },
                                .{ ._, ._, .mov, .memid(.dst0q, .tmp5, -8), .tmp1q, ._, ._ },
                                .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                .{ .@"1:", ._, .cmp, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                                .{ ._, ._b, .j, .@"0b", ._, ._, ._ },
                                .{ ._, ._, .@"test", .tmp0d, .si(0b111111), ._, ._ },
                                .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                                .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp1q, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .@"64bit", .sse, .slow_incdec, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .call_frame = .{ .alignment = .@"16" },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .u8, .kind = .{ .reg = .cl } },
                                .{ .type = .u64, .kind = .{ .reg = .rdx } },
                                .{ .type = .f32, .kind = .mem },
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                            .each = .{ .once = &.{
                                .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                                .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                .{ .@"0:", ._, .movzx, .tmp5d, .memsi(.src0w, .@"2", .tmp0), ._, ._ },
                                .{ ._, ._, .mov, .mem(.tmp8d), .tmp5d, ._, ._ },
                                .{ ._, ._ss, .mov, .tmp2x, .mem(.tmp8d), ._, ._ },
                                .{ ._, ._, .movzx, .tmp5d, .memsi(.src1w, .@"2", .tmp0), ._, ._ },
                                .{ ._, ._, .mov, .mem(.tmp8d), .tmp5d, ._, ._ },
                                .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp8d), ._, ._ },
                                .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                                .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                                .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ },
                                .{ ._, ._l, .sh, .tmp7q, .tmp6b, ._, ._ },
                                .{ ._, ._, .@"or", .tmp1q, .tmp7q, ._, ._ },
                                .{ ._, ._, .lea, .tmp0d, .lead(.tmp0, 1), ._, ._ },
                                .{ ._, ._, .@"test", .tmp0d, .si(0b111111), ._, ._ },
                                .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                                .{ ._, ._r, .sh, .tmp5d, .ui(3), ._, ._ },
                                .{ ._, ._, .mov, .memid(.dst0q, .tmp5, -8), .tmp1q, ._, ._ },
                                .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                .{ .@"1:", ._, .cmp, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                                .{ ._, ._b, .j, .@"0b", ._, ._, ._ },
                                .{ ._, ._, .@"test", .tmp0d, .si(0b111111), ._, ._ },
                                .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                                .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp1q, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .@"64bit", .sse, null, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .call_frame = .{ .alignment = .@"16" },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } },
                                .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .u8, .kind = .{ .reg = .cl } },
                                .{ .type = .u64, .kind = .{ .reg = .rdx } },
                                .{ .type = .f32, .kind = .mem },
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                            .each = .{ .once = &.{
                                .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                                .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                .{ .@"0:", ._, .movzx, .tmp5d, .memsi(.src0w, .@"2", .tmp0), ._, ._ },
                                .{ ._, ._, .mov, .mem(.tmp8d), .tmp5d, ._, ._ },
                                .{ ._, ._ss, .mov, .tmp2x, .mem(.tmp8d), ._, ._ },
                                .{ ._, ._, .movzx, .tmp5d, .memsi(.src1w, .@"2", .tmp0), ._, ._ },
                                .{ ._, ._, .mov, .mem(.tmp8d), .tmp5d, ._, ._ },
                                .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp8d), ._, ._ },
                                .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                                .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                                .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ },
                                .{ ._, ._l, .sh, .tmp7q, .tmp6b, ._, ._ },
                                .{ ._, ._, .@"or", .tmp1q, .tmp7q, ._, ._ },
                                .{ ._, ._c, .in, .tmp0d, ._, ._, ._ },
                                .{ ._, ._, .@"test", .tmp0d, .si(0b111111), ._, ._ },
                                .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ },
                                .{ ._, ._r, .sh, .tmp5d, .ui(3), ._, ._ },
                                .{ ._, ._, .mov, .memid(.dst0q, .tmp5, -8), .tmp1q, ._, ._ },
                                .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                .{ .@"1:", ._, .cmp, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                                .{ ._, ._b, .j, .@"0b", ._, ._, ._ },
                                .{ ._, ._, .@"test", .tmp0d, .si(0b111111), ._, ._ },
                                .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ },
                                .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp1q, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, .slow_incdec, null, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
                                .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                                .{ .@"0:", .v_ps, .mova, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                                .{ ._, .v_ps, .cmp, .tmp2y, .tmp2y, .memia(.src1y, .tmp0, .add_size), .vp(switch (cc) {
                                    else => unreachable,
                                    .e => .eq,
                                    .ne => .neq,
                                }) },
                                .{ ._, .v_ps, .movmsk, .tmp3d, .tmp2y, ._, ._ },
                                .{ ._, ._, .mov, .lea(.tmp1b), .tmp3b, ._, ._ },
                                .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 1), ._, ._ },
                                .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
                                .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                                .{ .@"0:", .v_ps, .mova, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                                .{ ._, .v_ps, .cmp, .tmp2y, .tmp2y, .memia(.src1y, .tmp0, .add_size), .vp(switch (cc) {
                                    else => unreachable,
                                    .e => .eq,
                                    .ne => .neq,
                                }) },
                                .{ ._, .v_ps, .movmsk, .tmp3d, .tmp2y, ._, ._ },
                                .{ ._, ._, .mov, .lea(.tmp1b), .tmp3b, ._, ._ },
                                .{ ._, ._c, .in, .tmp1q, ._, ._, ._ },
                                .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse2, null, null, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
                                .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                                .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                                .{ .@"0:", ._ps, .mova, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._ps, .mova, .tmp3x, .memiad(.src0x, .tmp0, .add_size, 16), ._, ._ },
                                .{ ._, ._ps, .cmp, .tmp2x, .memia(.src1x, .tmp0, .add_size), .sp(switch (cc) {
                                    else => unreachable,
                                    .e => .eq,
                                    .ne => .neq,
                                }), ._ },
                                .{ ._, ._ps, .cmp, .tmp3x, .memiad(.src1x, .tmp0, .add_size, 16), .sp(switch (cc) {
                                    else => unreachable,
                                    .e => .eq,
                                    .ne => .neq,
                                }), ._ },
                                .{ ._, .p_w, .ackssd, .tmp2x, .tmp3x, ._, ._ },
                                .{ ._, .p_b, .ackssw, .tmp2x, .tmp2x, ._, ._ },
                                .{ ._, .p_b, .movmsk, .tmp4d, .tmp2x, ._, ._ },
                                .{ ._, ._, .mov, .lea(.tmp1b), .tmp4b, ._, ._ },
                                .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 1), ._, ._ },
                                .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse, null, null, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
                                .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                                .{ .@"0:", ._ps, .mova, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._ps, .cmp, .tmp2x, .memia(.src1x, .tmp0, .add_size), .sp(switch (cc) {
                                    else => unreachable,
                                    .e => .eq,
                                    .ne => .neq,
                                }), ._ },
                                .{ ._, ._ps, .movmsk, .tmp3d, .tmp2x, ._, ._ },
                                .{ ._, ._ps, .mova, .tmp2x, .memiad(.src0x, .tmp0, .add_size, 16), ._, ._ },
                                .{ ._, ._ps, .cmp, .tmp2x, .memiad(.src1x, .tmp0, .add_size, 16), .sp(switch (cc) {
                                    else => unreachable,
                                    .e => .eq,
                                    .ne => .neq,
                                }), ._ },
                                .{ ._, ._ps, .movmsk, .tmp4d, .tmp2x, ._, ._ },
                                .{ ._, ._l, .sh, .tmp4b, .ui(4), ._, ._ },
                                .{ ._, ._, .@"or", .tmp3b, .tmp4b, ._, ._ },
                                .{ ._, ._, .mov, .lea(.tmp1b), .tmp3b, ._, ._ },
                                .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 1), ._, ._ },
                                .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse, null, null, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
                                .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                                .{ ._, ._mp, .j, .@"1f", ._, ._, ._ },
                                .{ .@"0:", ._ps, .mova, .tmp2x, .memiad(.src0x, .tmp0, .add_size, -16), ._, ._ },
                                .{ ._, ._ps, .cmp, .tmp2x, .memiad(.src1x, .tmp0, .add_size, -16), .sp(switch (cc) {
                                    else => unreachable,
                                    .e => .eq,
                                    .ne => .neq,
                                }), ._ },
                                .{ ._, ._ps, .movmsk, .tmp4d, .tmp2x, ._, ._ },
                                .{ ._, ._l, .sh, .tmp4b, .ui(4), ._, ._ },
                                .{ ._, ._, .@"or", .tmp3b, .tmp4b, ._, ._ },
                                .{ ._, ._, .mov, .lea(.tmp1b), .tmp3b, ._, ._ },
                                .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 1), ._, ._ },
                                .{ .@"1:", ._ps, .mova, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._ps, .cmp, .tmp2x, .memia(.src1x, .tmp0, .add_size), .sp(switch (cc) {
                                    else => unreachable,
                                    .e => .eq,
                                    .ne => .neq,
                                }), ._ },
                                .{ ._, ._ps, .movmsk, .tmp3d, .tmp2x, ._, ._ },
                                .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                .{ ._, ._, .mov, .lea(.tmp1b), .tmp3b, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, .slow_incdec, null, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .zword, .is = .qword } },
                                .{ .multiple_scalar_float = .{ .of = .zword, .is = .qword } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                                .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                                .{ .@"0:", .v_pd, .mova, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                                .{ ._, .v_pd, .mova, .tmp3y, .memiad(.src0y, .tmp0, .add_size, 32), ._, ._ },
                                .{ ._, .v_pd, .cmp, .tmp2y, .tmp2y, .memia(.src1y, .tmp0, .add_size), .vp(switch (cc) {
                                    else => unreachable,
                                    .e => .eq,
                                    .ne => .neq,
                                }) },
                                .{ ._, .v_pd, .cmp, .tmp3y, .tmp3y, .memiad(.src1y, .tmp0, .add_size, 32), .vp(switch (cc) {
                                    else => unreachable,
                                    .e => .eq,
                                    .ne => .neq,
                                }) },
                                .{ ._, .v_pd, .movmsk, .tmp4d, .tmp2y, ._, ._ },
                                .{ ._, .v_pd, .movmsk, .tmp5d, .tmp3y, ._, ._ },
                                .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ },
                                .{ ._, ._, .@"or", .tmp4b, .tmp5b, ._, ._ },
                                .{ ._, ._, .mov, .lea(.tmp1b), .tmp4b, ._, ._ },
                                .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 1), ._, ._ },
                                .{ ._, ._, .add, .tmp0p, .si(64), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .zword, .is = .qword } },
                                .{ .multiple_scalar_float = .{ .of = .zword, .is = .qword } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                                .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                                .{ .@"0:", .v_pd, .mova, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                                .{ ._, .v_pd, .mova, .tmp3y, .memiad(.src0y, .tmp0, .add_size, 32), ._, ._ },
                                .{ ._, .v_pd, .cmp, .tmp2y, .tmp2y, .memia(.src1y, .tmp0, .add_size), .vp(switch (cc) {
                                    else => unreachable,
                                    .e => .eq,
                                    .ne => .neq,
                                }) },
                                .{ ._, .v_pd, .cmp, .tmp3y, .tmp3y, .memiad(.src1y, .tmp0, .add_size, 32), .vp(switch (cc) {
                                    else => unreachable,
                                    .e => .eq,
                                    .ne => .neq,
                                }) },
                                .{ ._, .v_pd, .movmsk, .tmp4d, .tmp2y, ._, ._ },
                                .{ ._, .v_pd, .movmsk, .tmp5d, .tmp3y, ._, ._ },
                                .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ },
                                .{ ._, ._, .@"or", .tmp4b, .tmp5b, ._, ._ },
                                .{ ._, ._, .mov, .lea(.tmp1b), .tmp4b, ._, ._ },
                                .{ ._, ._c, .in, .tmp1q, ._, ._, ._ },
                                .{ ._, ._, .add, .tmp0p, .si(64), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
                                .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .reg = .rcx } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ .@"0:", .v_pd, .mova, .tmp3y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                                .{ ._, .v_pd, .cmp, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_size), .vp(switch (cc) {
                                    else => unreachable,
                                    .e => .eq,
                                    .ne => .neq,
                                }) },
                                .{ ._, .v_pd, .movmsk, .tmp4d, .tmp3y, ._, ._ },
                                .{ ._, ._l, .ro, .tmp4b, .tmp1b, ._, ._ },
                                .{ ._, ._, .@"or", .tmp2b, .tmp4b, ._, ._ },
                                .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 4), ._, ._ },
                                .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp4d, .tmp1d, ._, ._ },
                                .{ ._, ._r, .sh, .tmp4d, .ui(3), ._, ._ },
                                .{ ._, ._, .mov, .memid(.dst0b, .tmp4, -1), .tmp2b, ._, ._ },
                                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ .@"1:", ._, .add, .tmp0p, .si(32), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                .{ ._, ._r, .sh, .tmp1d, .ui(3), ._, ._ },
                                .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse2, null, null, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
                                .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .reg = .rcx } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ .@"0:", ._pd, .mova, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._pd, .cmp, .tmp3x, .memia(.src1x, .tmp0, .add_size), .sp(switch (cc) {
                                    else => unreachable,
                                    .e => .eq,
                                    .ne => .neq,
                                }), ._ },
                                .{ ._, ._pd, .movmsk, .tmp4d, .tmp3x, ._, ._ },
                                .{ ._, ._l, .ro, .tmp4b, .tmp1b, ._, ._ },
                                .{ ._, ._, .@"or", .tmp2b, .tmp4b, ._, ._ },
                                .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 2), ._, ._ },
                                .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp4d, .tmp1d, ._, ._ },
                                .{ ._, ._r, .sh, .tmp4d, .ui(3), ._, ._ },
                                .{ ._, ._, .mov, .memid(.dst0b, .tmp4, -1), .tmp2b, ._, ._ },
                                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                .{ ._, ._r, .sh, .tmp1d, .ui(3), ._, ._ },
                                .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .x87, .cmov, .slow_incdec, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                                .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .reg = .rcx } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .f64, .kind = .{ .reg = .st6 } },
                                .{ .type = .f64, .kind = .{ .reg = .st7 } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ .@"0:", ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                                .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                                .{ ._, .f_, .ld, .memia(.src1q, .tmp0, .add_size), ._, ._, ._ },
                                .{ ._, .f_, .ld, .memia(.src0q, .tmp0, .add_size), ._, ._, ._ },
                                .{ ._, .f_p, .ucomi, .tmp5t, .tmp6t, ._, ._ },
                                .{ ._, .f_p, .st, .tmp6t, ._, ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp3b, ._, ._, ._ },
                                .{ ._, switch (cc) {
                                    else => unreachable,
                                    .e => ._np,
                                    .ne => ._p,
                                }, .set, .tmp4b, ._, ._, ._ },
                                .{ ._, ._, switch (cc) {
                                    else => unreachable,
                                    .e => .@"and",
                                    .ne => .@"or",
                                }, .tmp3b, .tmp4b, ._, ._ },
                                .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ },
                                .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ },
                                .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 1), ._, ._ },
                                .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ },
                                .{ ._, ._r, .sh, .tmp3d, .ui(3), ._, ._ },
                                .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ },
                                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ .@"1:", ._, .add, .tmp0p, .si(8), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                .{ ._, ._r, .sh, .tmp1d, .ui(3), ._, ._ },
                                .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .x87, .cmov, null, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                                .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .reg = .rcx } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .f64, .kind = .{ .reg = .st6 } },
                                .{ .type = .f64, .kind = .{ .reg = .st7 } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ .@"0:", ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                                .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                                .{ ._, .f_, .ld, .memia(.src1q, .tmp0, .add_size), ._, ._, ._ },
                                .{ ._, .f_, .ld, .memia(.src0q, .tmp0, .add_size), ._, ._, ._ },
                                .{ ._, .f_p, .ucomi, .tmp5t, .tmp6t, ._, ._ },
                                .{ ._, .f_p, .st, .tmp6t, ._, ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp3b, ._, ._, ._ },
                                .{ ._, switch (cc) {
                                    else => unreachable,
                                    .e => ._np,
                                    .ne => ._p,
                                }, .set, .tmp4b, ._, ._, ._ },
                                .{ ._, ._, switch (cc) {
                                    else => unreachable,
                                    .e => .@"and",
                                    .ne => .@"or",
                                }, .tmp3b, .tmp4b, ._, ._ },
                                .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ },
                                .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ },
                                .{ ._, ._c, .in, .tmp1d, ._, ._, ._ },
                                .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ },
                                .{ ._, ._r, .sh, .tmp3d, .ui(3), ._, ._ },
                                .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ },
                                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ .@"1:", ._, .add, .tmp0p, .si(8), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                .{ ._, ._r, .sh, .tmp1d, .ui(3), ._, ._ },
                                .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .x87, null, null, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                                .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .reg = .rcx } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .f64, .kind = .{ .reg = .st6 } },
                                .{ .type = .f64, .kind = .{ .reg = .st7 } },
                                .{ .type = .u16, .kind = .{ .reg = .ax } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ .@"0:", ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                                .{ ._, .f_, .ld, .memia(.src1q, .tmp0, .add_size), ._, ._, ._ },
                                .{ ._, .f_, .ld, .memia(.src0q, .tmp0, .add_size), ._, ._, ._ },
                                .{ ._, .f_pp, .ucom, ._, ._, ._, ._ },
                                .{ ._, .fn_sw, .st, .tmp6w, ._, ._, ._ },
                                .{ ._, ._, .xor, .tmp6h, .si(0b1_000_000), ._, ._ },
                                .{ ._, ._, .@"test", .tmp6h, .si(0b1_000_100), ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp3b, ._, ._, ._ },
                                .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ },
                                .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ },
                                .{ ._, ._c, .in, .tmp1d, ._, ._, ._ },
                                .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ },
                                .{ ._, ._r, .sh, .tmp3d, .ui(3), ._, ._ },
                                .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ },
                                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ .@"1:", ._, .add, .tmp0p, .si(8), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                .{ ._, ._r, .sh, .tmp1d, .ui(3), ._, ._ },
                                .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .x87, .cmov, .slow_incdec, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                                .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .reg = .rcx } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .f80, .kind = .{ .reg = .st6 } },
                                .{ .type = .f80, .kind = .{ .reg = .st7 } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ .@"0:", ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                                .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                                .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_size), ._, ._, ._ },
                                .{ ._, .f_, .ld, .memia(.src0t, .tmp0, .add_size), ._, ._, ._ },
                                .{ ._, .f_p, .ucomi, .tmp5t, .tmp6t, ._, ._ },
                                .{ ._, .f_p, .st, .tmp6t, ._, ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp3b, ._, ._, ._ },
                                .{ ._, switch (cc) {
                                    else => unreachable,
                                    .e => ._np,
                                    .ne => ._p,
                                }, .set, .tmp4b, ._, ._, ._ },
                                .{ ._, ._, switch (cc) {
                                    else => unreachable,
                                    .e => .@"and",
                                    .ne => .@"or",
                                }, .tmp3b, .tmp4b, ._, ._ },
                                .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ },
                                .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ },
                                .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 1), ._, ._ },
                                .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ },
                                .{ ._, ._r, .sh, .tmp3d, .ui(3), ._, ._ },
                                .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ },
                                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                .{ ._, ._r, .sh, .tmp1d, .ui(3), ._, ._ },
                                .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .x87, .cmov, null, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                                .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .reg = .rcx } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .f80, .kind = .{ .reg = .st6 } },
                                .{ .type = .f80, .kind = .{ .reg = .st7 } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ .@"0:", ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                                .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                                .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_size), ._, ._, ._ },
                                .{ ._, .f_, .ld, .memia(.src0t, .tmp0, .add_size), ._, ._, ._ },
                                .{ ._, .f_p, .ucomi, .tmp5t, .tmp6t, ._, ._ },
                                .{ ._, .f_p, .st, .tmp6t, ._, ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp3b, ._, ._, ._ },
                                .{ ._, switch (cc) {
                                    else => unreachable,
                                    .e => ._np,
                                    .ne => ._p,
                                }, .set, .tmp4b, ._, ._, ._ },
                                .{ ._, ._, switch (cc) {
                                    else => unreachable,
                                    .e => .@"and",
                                    .ne => .@"or",
                                }, .tmp3b, .tmp4b, ._, ._ },
                                .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ },
                                .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ },
                                .{ ._, ._c, .in, .tmp1d, ._, ._, ._ },
                                .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ },
                                .{ ._, ._r, .sh, .tmp3d, .ui(3), ._, ._ },
                                .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ },
                                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                .{ ._, ._r, .sh, .tmp1d, .ui(3), ._, ._ },
                                .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .x87, null, null, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                                .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .reg = .rcx } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .f80, .kind = .{ .reg = .st6 } },
                                .{ .type = .f80, .kind = .{ .reg = .st7 } },
                                .{ .type = .u16, .kind = .{ .reg = .ax } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ .@"0:", ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                                .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_size), ._, ._, ._ },
                                .{ ._, .f_, .ld, .memia(.src0t, .tmp0, .add_size), ._, ._, ._ },
                                .{ ._, .f_pp, .ucom, ._, ._, ._, ._ },
                                .{ ._, .fn_sw, .st, .tmp6w, ._, ._, ._ },
                                .{ ._, ._, .xor, .tmp6h, .si(0b1_000_000), ._, ._ },
                                .{ ._, ._, .@"test", .tmp6h, .si(0b1_000_100), ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp3b, ._, ._, ._ },
                                .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ },
                                .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ },
                                .{ ._, ._c, .in, .tmp1d, ._, ._, ._ },
                                .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ },
                                .{ ._, ._r, .sh, .tmp3d, .ui(3), ._, ._ },
                                .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ },
                                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ },
                                .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                .{ ._, ._r, .sh, .tmp1d, .ui(3), ._, ._ },
                                .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, .slow_incdec, null, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                .any,
                            },
                            .dst_constraints = .{ .{ .bool_vec = .dword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .call_frame = .{ .alignment = .@"16" },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .u8, .kind = .{ .reg = .cl } },
                                .{ .type = .u32, .kind = .{ .reg = .edx } },
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                            .each = .{ .once = &.{
                                .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                .{ .@"0:", .v_dqa, .mov, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                .{ ._, .v_dqa, .mov, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                                .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                                .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ },
                                .{ ._, ._l, .sh, .tmp7d, .tmp6b, ._, ._ },
                                .{ ._, ._, .@"or", .dst0d, .tmp7d, ._, ._ },
                                .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 1), ._, ._ },
                                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, .slow_incdec, null, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                .any,
                            },
                            .dst_constraints = .{ .{ .bool_vec = .dword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .call_frame = .{ .alignment = .@"16" },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .u8, .kind = .{ .reg = .cl } },
                                .{ .type = .u32, .kind = .{ .reg = .edx } },
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                            .each = .{ .once = &.{
                                .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                .{ .@"0:", .v_dqa, .mov, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                .{ ._, .v_dqa, .mov, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                                .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                                .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ },
                                .{ ._, ._l, .sh, .tmp7d, .tmp6b, ._, ._ },
                                .{ ._, ._, .@"or", .dst0d, .tmp7d, ._, ._ },
                                .{ ._, ._c, .in, .tmp1d, ._, ._, ._ },
                                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse2, .slow_incdec, null, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                .any,
                            },
                            .dst_constraints = .{ .{ .bool_vec = .dword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .call_frame = .{ .alignment = .@"16" },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .u8, .kind = .{ .reg = .cl } },
                                .{ .type = .u32, .kind = .{ .reg = .edx } },
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                            .each = .{ .once = &.{
                                .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                .{ .@"0:", ._dqa, .mov, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._dqa, .mov, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                                .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                                .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ },
                                .{ ._, ._l, .sh, .tmp7d, .tmp6b, ._, ._ },
                                .{ ._, ._, .@"or", .dst0d, .tmp7d, ._, ._ },
                                .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 1), ._, ._ },
                                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse2, .slow_incdec, null, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                .any,
                            },
                            .dst_constraints = .{ .{ .bool_vec = .dword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .call_frame = .{ .alignment = .@"16" },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .u8, .kind = .{ .reg = .cl } },
                                .{ .type = .u32, .kind = .{ .reg = .edx } },
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                            .each = .{ .once = &.{
                                .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                .{ .@"0:", ._dqa, .mov, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._dqa, .mov, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                                .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                                .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ },
                                .{ ._, ._l, .sh, .tmp7d, .tmp6b, ._, ._ },
                                .{ ._, ._, .@"or", .dst0d, .tmp7d, ._, ._ },
                                .{ ._, ._c, .in, .tmp1d, ._, ._, ._ },
                                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse, .slow_incdec, null, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                .any,
                            },
                            .dst_constraints = .{ .{ .bool_vec = .dword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .call_frame = .{ .alignment = .@"16" },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .u8, .kind = .{ .reg = .cl } },
                                .{ .type = .u32, .kind = .{ .reg = .edx } },
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                            .each = .{ .once = &.{
                                .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                .{ .@"0:", ._ps, .mova, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._ps, .mova, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                                .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                                .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ },
                                .{ ._, ._l, .sh, .tmp7d, .tmp6b, ._, ._ },
                                .{ ._, ._, .@"or", .dst0d, .tmp7d, ._, ._ },
                                .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 1), ._, ._ },
                                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse2, .slow_incdec, null, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                .any,
                            },
                            .dst_constraints = .{ .{ .bool_vec = .dword }, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .call_frame = .{ .alignment = .@"16" },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .u8, .kind = .{ .reg = .cl } },
                                .{ .type = .u32, .kind = .{ .reg = .edx } },
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                            .each = .{ .once = &.{
                                .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ },
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                .{ .@"0:", ._ps, .mova, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._ps, .mova, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                                .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                                .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ },
                                .{ ._, ._l, .sh, .tmp7d, .tmp6b, ._, ._ },
                                .{ ._, ._, .@"or", .dst0d, .tmp7d, ._, ._ },
                                .{ ._, ._c, .in, .tmp1d, ._, ._, ._ },
                                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .@"64bit", .avx, .slow_incdec, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .call_frame = .{ .alignment = .@"16" },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .u8, .kind = .{ .reg = .cl } },
                                .{ .type = .u64, .kind = .{ .reg = .rdx } },
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ .@"0:", .v_dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                .{ ._, .v_dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                                .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                                .{ ._, ._, .@"test", .tmp6d, .tmp6d, ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp8b, ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp7d, .tmp1d, ._, ._ },
                                .{ ._, ._l, .sh, .tmp8q, .tmp7b, ._, ._ },
                                .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ },
                                .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 1), ._, ._ },
                                .{ ._, ._, .@"test", .tmp1d, .si(0b111111), ._, ._ },
                                .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ },
                                .{ ._, ._r, .sh, .tmp6d, .ui(3), ._, ._ },
                                .{ ._, ._, .mov, .memid(.dst0q, .tmp6, -8), .tmp2q, ._, ._ },
                                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                .{ ._, ._, .@"test", .tmp1d, .si(0b111111), ._, ._ },
                                .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                .{ ._, ._r, .sh, .tmp1d, .ui(6), ._, ._ },
                                .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp1), .tmp2q, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .@"64bit", .avx, null, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .call_frame = .{ .alignment = .@"16" },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .u8, .kind = .{ .reg = .cl } },
                                .{ .type = .u64, .kind = .{ .reg = .rdx } },
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ .@"0:", .v_dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                .{ ._, .v_dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                                .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                                .{ ._, ._, .@"test", .tmp6d, .tmp6d, ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp8b, ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp7d, .tmp1d, ._, ._ },
                                .{ ._, ._l, .sh, .tmp8q, .tmp7b, ._, ._ },
                                .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ },
                                .{ ._, ._c, .in, .tmp1d, ._, ._, ._ },
                                .{ ._, ._, .@"test", .tmp1d, .si(0b111111), ._, ._ },
                                .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ },
                                .{ ._, ._r, .sh, .tmp6d, .ui(3), ._, ._ },
                                .{ ._, ._, .mov, .memid(.dst0q, .tmp6, -8), .tmp2q, ._, ._ },
                                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                .{ ._, ._, .@"test", .tmp1d, .si(0b111111), ._, ._ },
                                .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                .{ ._, ._r, .sh, .tmp1d, .ui(6), ._, ._ },
                                .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp1), .tmp2q, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .@"64bit", .sse2, .slow_incdec, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .call_frame = .{ .alignment = .@"16" },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .u8, .kind = .{ .reg = .cl } },
                                .{ .type = .u64, .kind = .{ .reg = .rdx } },
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ .@"0:", ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                                .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                                .{ ._, ._, .@"test", .tmp6d, .tmp6d, ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp8b, ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp7d, .tmp1d, ._, ._ },
                                .{ ._, ._l, .sh, .tmp8q, .tmp7b, ._, ._ },
                                .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ },
                                .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 1), ._, ._ },
                                .{ ._, ._, .@"test", .tmp1d, .si(0b111111), ._, ._ },
                                .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ },
                                .{ ._, ._r, .sh, .tmp6d, .ui(3), ._, ._ },
                                .{ ._, ._, .mov, .memid(.dst0q, .tmp6, -8), .tmp2q, ._, ._ },
                                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                .{ ._, ._, .@"test", .tmp1d, .si(0b111111), ._, ._ },
                                .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                .{ ._, ._r, .sh, .tmp1d, .ui(6), ._, ._ },
                                .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp1), .tmp2q, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .@"64bit", .sse2, null, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .call_frame = .{ .alignment = .@"16" },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .u8, .kind = .{ .reg = .cl } },
                                .{ .type = .u64, .kind = .{ .reg = .rdx } },
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ .@"0:", ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                                .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                                .{ ._, ._, .@"test", .tmp6d, .tmp6d, ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp8b, ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp7d, .tmp1d, ._, ._ },
                                .{ ._, ._l, .sh, .tmp8q, .tmp7b, ._, ._ },
                                .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ },
                                .{ ._, ._c, .in, .tmp1d, ._, ._, ._ },
                                .{ ._, ._, .@"test", .tmp1d, .si(0b111111), ._, ._ },
                                .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ },
                                .{ ._, ._r, .sh, .tmp6d, .ui(3), ._, ._ },
                                .{ ._, ._, .mov, .memid(.dst0q, .tmp6, -8), .tmp2q, ._, ._ },
                                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                .{ ._, ._, .@"test", .tmp1d, .si(0b111111), ._, ._ },
                                .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                .{ ._, ._r, .sh, .tmp1d, .ui(6), ._, ._ },
                                .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp1), .tmp2q, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .@"64bit", .sse, .slow_incdec, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .call_frame = .{ .alignment = .@"16" },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .u8, .kind = .{ .reg = .cl } },
                                .{ .type = .u64, .kind = .{ .reg = .rdx } },
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ .@"0:", ._ps, .mova, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._ps, .mova, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                                .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                                .{ ._, ._, .@"test", .tmp6d, .tmp6d, ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp8b, ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp7d, .tmp1d, ._, ._ },
                                .{ ._, ._l, .sh, .tmp8q, .tmp7b, ._, ._ },
                                .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ },
                                .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 1), ._, ._ },
                                .{ ._, ._, .@"test", .tmp1d, .si(0b111111), ._, ._ },
                                .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ },
                                .{ ._, ._r, .sh, .tmp6d, .ui(3), ._, ._ },
                                .{ ._, ._, .mov, .memid(.dst0q, .tmp6, -8), .tmp2q, ._, ._ },
                                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                .{ ._, ._, .@"test", .tmp1d, .si(0b111111), ._, ._ },
                                .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                .{ ._, ._r, .sh, .tmp1d, .ui(6), ._, ._ },
                                .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp1), .tmp2q, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .@"64bit", .sse, null, null },
                            .src_constraints = .{
                                .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                                .any,
                            },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .to_mem, .none } },
                            },
                            .call_frame = .{ .alignment = .@"16" },
                            .extra_temps = .{
                                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                                .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } },
                                .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                                .{ .type = .u8, .kind = .{ .reg = .cl } },
                                .{ .type = .u64, .kind = .{ .reg = .rdx } },
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                                .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ .@"0:", ._ps, .mova, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._ps, .mova, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                                .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                                .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
                                .{ ._, ._, .@"test", .tmp6d, .tmp6d, ._, ._ },
                                .{ ._, .fromCond(cc), .set, .tmp8b, ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp7d, .tmp1d, ._, ._ },
                                .{ ._, ._l, .sh, .tmp8q, .tmp7b, ._, ._ },
                                .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ },
                                .{ ._, ._c, .in, .tmp1d, ._, ._, ._ },
                                .{ ._, ._, .@"test", .tmp1d, .si(0b111111), ._, ._ },
                                .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                                .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ },
                                .{ ._, ._r, .sh, .tmp6d, .ui(3), ._, ._ },
                                .{ ._, ._, .mov, .memid(.dst0q, .tmp6, -8), .tmp2q, ._, ._ },
                                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                                .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ },
                                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                                .{ ._, ._, .@"test", .tmp1d, .si(0b111111), ._, ._ },
                                .{ ._, ._z, .j, .@"0f", ._, ._, ._ },
                                .{ ._, ._r, .sh, .tmp1d, .ui(6), ._, ._ },
                                .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp1), .tmp2q, ._, ._ },
                            } },
                        } },
                    }),
                }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {s} {f} {f} {f}", .{
                        @tagName(air_tag),
                        @tagName(vector_cmp.compareOperator()),
                        cg.typeOf(vector_cmp.lhs).fmt(pt),
                        ops[0].tracking(cg),
                        ops[1].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{ vector_cmp.lhs, vector_cmp.rhs }, &ops, cg);
            },
            .cond_br => try cg.airCondBr(inst),
            .switch_br => try cg.airSwitchBr(inst),
            .loop_switch_br => try cg.airLoopSwitchBr(inst),
            .switch_dispatch => try cg.airSwitchDispatch(inst),
            .@"try", .try_cold => try cg.airTry(inst),
            .try_ptr, .try_ptr_cold => try cg.airTryPtr(inst),
            .dbg_stmt => if (!cg.mod.strip) {
                const dbg_stmt = air_datas[@intFromEnum(inst)].dbg_stmt;
                _ = try cg.addInst(.{
                    .tag = .pseudo,
                    .ops = .pseudo_dbg_line_stmt_line_column,
                    .data = .{ .line_column = .{
                        .line = dbg_stmt.line,
                        .column = dbg_stmt.column,
                    } },
                });
            },
            .dbg_empty_stmt => if (!cg.mod.strip) {
                if (cg.mir_instructions.len > 0) {
                    const prev_mir_op = &cg.mir_instructions.items(.ops)[cg.mir_instructions.len - 1];
                    if (prev_mir_op.* == .pseudo_dbg_line_line_column)
                        prev_mir_op.* = .pseudo_dbg_line_stmt_line_column;
                }
                try cg.asmOpOnly(.{ ._, .nop });
            },
            .dbg_inline_block => {
                const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
                const dbg_inline_block = cg.air.extraData(Air.DbgInlineBlock, ty_pl.payload);
                const old_inline_func = cg.inline_func;
                defer cg.inline_func = old_inline_func;
                cg.inline_func = dbg_inline_block.data.func;
                if (!cg.mod.strip) _ = try cg.addInst(.{
                    .tag = .pseudo,
                    .ops = .pseudo_dbg_enter_inline_func,
                    .data = .{ .ip_index = dbg_inline_block.data.func },
                });
                try cg.lowerBlock(inst, @ptrCast(cg.air.extra.items[dbg_inline_block.end..][0..dbg_inline_block.data.body_len]));
                if (!cg.mod.strip) _ = try cg.addInst(.{
                    .tag = .pseudo,
                    .ops = .pseudo_dbg_leave_inline_func,
                    .data = .{ .ip_index = old_inline_func },
                });
            },
            .dbg_var_ptr, .dbg_var_val, .dbg_arg_inline => |air_tag| if (!cg.mod.strip) {
                const pl_op = air_datas[@intFromEnum(inst)].pl_op;
                const air_name: Air.NullTerminatedString = @enumFromInt(pl_op.payload);
                const op_ty = cg.typeOf(pl_op.operand);
                const local_ty = switch (air_tag) {
                    else => unreachable,
                    .dbg_var_ptr => op_ty.childType(zcu),
                    .dbg_var_val, .dbg_arg_inline => op_ty,
                };
                var ops = try cg.tempsFromOperands(inst, .{pl_op.operand});
                var mcv = ops[0].tracking(cg).short;
                switch (mcv) {
                    else => {},
                    .eflags => |cc| switch (cc) {
                        else => {},
                        // These values would self destruct. Maybe we make them use their
                        // turing complete dwarf expression interpreters for once?
                        .z_and_np, .nz_or_p => {
                            try cg.spillEflagsIfOccupied();
                            mcv = ops[0].tracking(cg).short;
                        },
                    },
                }

                try cg.mir_locals.append(cg.gpa, .{
                    .name = switch (air_name) {
                        .none => switch (air_tag) {
                            else => unreachable,
                            .dbg_arg_inline => .none,
                        },
                        else => try cg.addString(air_name.toSlice(cg.air)),
                    },
                    .type = local_ty.toIntern(),
                });

                try cg.genLocalDebugInfo(air_tag, local_ty, ops[0].tracking(cg).short);
                try ops[0].die(cg);
            },
            .is_null => {
                const un_op = air_datas[@intFromEnum(inst)].un_op;
                const opt_ty = cg.typeOf(un_op);
                const opt_repr_is_pl = opt_ty.optionalReprIsPayload(zcu);
                const opt_child_ty = opt_ty.optionalChild(zcu);
                const opt_child_abi_size: u31 = @intCast(opt_child_ty.abiSize(zcu));
                try cg.spillEflagsIfOccupied();
                var ops = try cg.tempsFromOperands(inst, .{un_op});
                while (try ops[0].toBase(false, cg)) {}
                try cg.asmMemoryImmediate(
                    .{ ._, .cmp },
                    try ops[0].tracking(cg).short.mem(cg, .{
                        .size = if (!opt_repr_is_pl)
                            .byte
                        else if (opt_child_ty.isSlice(zcu))
                            .ptr
                        else
                            .fromSize(opt_child_abi_size),
                        .disp = if (opt_repr_is_pl) 0 else opt_child_abi_size,
                    }),
                    .u(0),
                );
                const is_null = try cg.tempInit(.bool, .{ .eflags = .e });
                try is_null.finish(inst, &.{un_op}, &ops, cg);
            },
            .is_non_null => {
                const un_op = air_datas[@intFromEnum(inst)].un_op;
                const opt_ty = cg.typeOf(un_op);
                const opt_repr_is_pl = opt_ty.optionalReprIsPayload(zcu);
                const opt_child_ty = opt_ty.optionalChild(zcu);
                const opt_child_abi_size: u31 = @intCast(opt_child_ty.abiSize(zcu));
                try cg.spillEflagsIfOccupied();
                var ops = try cg.tempsFromOperands(inst, .{un_op});
                while (try ops[0].toBase(false, cg)) {}
                try cg.asmMemoryImmediate(
                    .{ ._, .cmp },
                    try ops[0].tracking(cg).short.mem(cg, .{
                        .size = if (!opt_repr_is_pl)
                            .byte
                        else if (opt_child_ty.isSlice(zcu))
                            .ptr
                        else
                            .fromSize(opt_child_abi_size),
                        .disp = if (opt_repr_is_pl) 0 else opt_child_abi_size,
                    }),
                    .u(0),
                );
                const is_non_null = try cg.tempInit(.bool, .{ .eflags = .ne });
                try is_non_null.finish(inst, &.{un_op}, &ops, cg);
            },
            .is_null_ptr => {
                const un_op = air_datas[@intFromEnum(inst)].un_op;
                const opt_ty = cg.typeOf(un_op).childType(zcu);
                const opt_repr_is_pl = opt_ty.optionalReprIsPayload(zcu);
                const opt_child_ty = opt_ty.optionalChild(zcu);
                const opt_child_abi_size: u31 = @intCast(opt_child_ty.abiSize(zcu));
                try cg.spillEflagsIfOccupied();
                var ops = try cg.tempsFromOperands(inst, .{un_op});
                if (!opt_repr_is_pl) try ops[0].toOffset(opt_child_abi_size, cg);
                while (try ops[0].toLea(cg)) {}
                try cg.asmMemoryImmediate(
                    .{ ._, .cmp },
                    try ops[0].tracking(cg).short.deref().mem(cg, .{ .size = if (!opt_repr_is_pl)
                        .byte
                    else if (opt_child_ty.isSlice(zcu))
                        .ptr
                    else
                        .fromSize(opt_child_abi_size) }),
                    .u(0),
                );
                const is_null = try cg.tempInit(.bool, .{ .eflags = .e });
                try is_null.finish(inst, &.{un_op}, &ops, cg);
            },
            .is_non_null_ptr => {
                const un_op = air_datas[@intFromEnum(inst)].un_op;
                const opt_ty = cg.typeOf(un_op).childType(zcu);
                const opt_repr_is_pl = opt_ty.optionalReprIsPayload(zcu);
                const opt_child_ty = opt_ty.optionalChild(zcu);
                const opt_child_abi_size: u31 = @intCast(opt_child_ty.abiSize(zcu));
                try cg.spillEflagsIfOccupied();
                var ops = try cg.tempsFromOperands(inst, .{un_op});
                if (!opt_repr_is_pl) try ops[0].toOffset(opt_child_abi_size, cg);
                while (try ops[0].toLea(cg)) {}
                try cg.asmMemoryImmediate(
                    .{ ._, .cmp },
                    try ops[0].tracking(cg).short.deref().mem(cg, .{ .size = if (!opt_repr_is_pl)
                        .byte
                    else if (opt_child_ty.isSlice(zcu))
                        .ptr
                    else
                        .fromSize(opt_child_abi_size) }),
                    .u(0),
                );
                const is_non_null = try cg.tempInit(.bool, .{ .eflags = .ne });
                try is_non_null.finish(inst, &.{un_op}, &ops, cg);
            },
            .is_err => {
                const un_op = air_datas[@intFromEnum(inst)].un_op;
                const eu_ty = cg.typeOf(un_op);
                const eu_err_ty = eu_ty.errorUnionSet(zcu);
                const eu_pl_ty = eu_ty.errorUnionPayload(zcu);
                const eu_err_off: u31 = @intCast(codegen.errUnionErrorOffset(eu_pl_ty, zcu));
                try cg.spillEflagsIfOccupied();
                var ops = try cg.tempsFromOperands(inst, .{un_op});
                while (try ops[0].toBase(false, cg)) {}
                try cg.asmMemoryImmediate(.{ ._, .cmp }, try ops[0].tracking(cg).short.mem(cg, .{
                    .size = cg.memSize(eu_err_ty),
                    .disp = eu_err_off,
                }), .u(0));
                const is_err = try cg.tempInit(.bool, .{ .eflags = .ne });
                try is_err.finish(inst, &.{un_op}, &ops, cg);
            },
            .is_non_err => {
                const un_op = air_datas[@intFromEnum(inst)].un_op;
                const eu_ty = cg.typeOf(un_op);
                const eu_err_ty = eu_ty.errorUnionSet(zcu);
                const eu_pl_ty = eu_ty.errorUnionPayload(zcu);
                const eu_err_off: u31 = @intCast(codegen.errUnionErrorOffset(eu_pl_ty, zcu));
                try cg.spillEflagsIfOccupied();
                var ops = try cg.tempsFromOperands(inst, .{un_op});
                while (try ops[0].toBase(false, cg)) {}
                try cg.asmMemoryImmediate(.{ ._, .cmp }, try ops[0].tracking(cg).short.mem(cg, .{
                    .size = cg.memSize(eu_err_ty),
                    .disp = eu_err_off,
                }), .u(0));
                const is_non_err = try cg.tempInit(.bool, .{ .eflags = .e });
                try is_non_err.finish(inst, &.{un_op}, &ops, cg);
            },
            .is_err_ptr => {
                const un_op = air_datas[@intFromEnum(inst)].un_op;
                const eu_ty = cg.typeOf(un_op).childType(zcu);
                const eu_err_ty = eu_ty.errorUnionSet(zcu);
                const eu_pl_ty = eu_ty.errorUnionPayload(zcu);
                const eu_err_off: u31 = @intCast(codegen.errUnionErrorOffset(eu_pl_ty, zcu));
                try cg.spillEflagsIfOccupied();
                var ops = try cg.tempsFromOperands(inst, .{un_op});
                try ops[0].toOffset(eu_err_off, cg);
                while (try ops[0].toLea(cg)) {}
                try cg.asmMemoryImmediate(
                    .{ ._, .cmp },
                    try ops[0].tracking(cg).short.deref().mem(cg, .{ .size = cg.memSize(eu_err_ty) }),
                    .u(0),
                );
                const is_err = try cg.tempInit(.bool, .{ .eflags = .ne });
                try is_err.finish(inst, &.{un_op}, &ops, cg);
            },
            .is_non_err_ptr => {
                const un_op = air_datas[@intFromEnum(inst)].un_op;
                const eu_ty = cg.typeOf(un_op).childType(zcu);
                const eu_err_ty = eu_ty.errorUnionSet(zcu);
                const eu_pl_ty = eu_ty.errorUnionPayload(zcu);
                const eu_err_off: u31 = @intCast(codegen.errUnionErrorOffset(eu_pl_ty, zcu));
                try cg.spillEflagsIfOccupied();
                var ops = try cg.tempsFromOperands(inst, .{un_op});
                try ops[0].toOffset(eu_err_off, cg);
                while (try ops[0].toLea(cg)) {}
                try cg.asmMemoryImmediate(
                    .{ ._, .cmp },
                    try ops[0].tracking(cg).short.deref().mem(cg, .{ .size = cg.memSize(eu_err_ty) }),
                    .u(0),
                );
                const is_non_err = try cg.tempInit(.bool, .{ .eflags = .e });
                try is_non_err.finish(inst, &.{un_op}, &ops, cg);
            },
            .load => {
                const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                const val_ty = ty_op.ty.toType();
                var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                var res: [1]Temp = undefined;
                cg.select(&res, &.{val_ty}, &ops, comptime &.{ .{
                    .src_constraints = .{ .{ .ptr_bool_vec_elem = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .cc = .c }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .lea(.src0b), ._, ._ },
                        .{ ._, ._, .bt, .tmp0d, .ua(.src0, .add_vector_index), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .ptr_bool_vec_elem = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .cc = .c }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .bt, .lea(.src0w), .ua(.src0, .add_vector_index), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .ptr_any_bool_vec_elem, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .cc = .c }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .bt, .leaa(.src0d, .add_vector_index_div_8_down_4), .ua(.src0, .add_vector_index_rem_32), ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => res[0] = try ops[0].load(val_ty, .{
                        .disp = switch (cg.typeOf(ty_op.operand).ptrInfo(zcu).flags.vector_index) {
                            .none => 0,
                            else => |vector_index| @intCast(val_ty.abiSize(zcu) * @intFromEnum(vector_index)),
                        },
                    }, cg),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{ty_op.operand}, &ops, cg);
            },
            .ret => try cg.airRet(inst, false),
            .ret_safe => try cg.airRet(inst, true),
            .ret_load => try cg.airRetLoad(inst),
            .store, .store_safe => |air_tag| {
                const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                cg.select(&.{}, &.{}, &ops, comptime &.{ .{
                    .src_constraints = .{ .{ .ptr_bool_vec_elem = .byte }, .bool, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .{ .imm = 0 }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .lea(.src0b), ._, ._ },
                        .{ ._, ._r, .bt, .tmp0d, .ua(.src0, .add_vector_index), ._, ._ },
                        .{ ._, ._, .mov, .lea(.src0b), .tmp0b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .ptr_bool_vec_elem = .byte }, .bool, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .{ .imm = 1 }, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .lea(.src0b), ._, ._ },
                        .{ ._, ._s, .bt, .tmp0d, .ua(.src0, .add_vector_index), ._, ._ },
                        .{ ._, ._, .mov, .lea(.src0b), .tmp0b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .ptr_bool_vec_elem = .byte }, .bool, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .lea(.src0b), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .bt, .tmp1d, .ua(.src0, .add_vector_index), ._, ._ },
                        .{ ._, ._s, .bt, .tmp0d, .ua(.src0, .add_vector_index), ._, ._ },
                        .{ ._, ._, .@"test", .src1b, .si(1), ._, ._ },
                        .{ ._, ._z, .cmov, .tmp0d, .tmp1d, ._, ._ },
                        .{ ._, ._, .mov, .lea(.src0b), .tmp0b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .ptr_bool_vec_elem = .byte }, .bool, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .lea(.src0b), ._, ._ },
                        .{ ._, ._, .@"test", .src1b, .si(1), ._, ._ },
                        .{ ._, ._nz, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .bt, .tmp0d, .ua(.src0, .add_vector_index), ._, ._ },
                        .{ ._, ._mp, .j, .@"1f", ._, ._, ._ },
                        .{ .@"0:", ._s, .bt, .tmp0d, .ua(.src0, .add_vector_index), ._, ._ },
                        .{ .@"1:", ._, .mov, .lea(.src0b), .tmp0b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .ptr_bool_vec_elem = .word }, .bool, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .{ .imm = 0 }, .none } },
                    },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._r, .bt, .lea(.src0w), .ua(.src0, .add_vector_index), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .ptr_bool_vec_elem = .word }, .bool, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .{ .imm = 1 }, .none } },
                    },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._s, .bt, .lea(.src0w), .ua(.src0, .add_vector_index), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .ptr_bool_vec_elem = .word }, .bool, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .lea(.src0w), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .bt, .tmp1d, .ua(.src0, .add_vector_index), ._, ._ },
                        .{ ._, ._s, .bt, .tmp0d, .ua(.src0, .add_vector_index), ._, ._ },
                        .{ ._, ._, .@"test", .src1b, .si(1), ._, ._ },
                        .{ ._, ._z, .cmov, .tmp0d, .tmp1d, ._, ._ },
                        .{ ._, ._, .mov, .lea(.src0w), .tmp0w, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .ptr_bool_vec_elem = .word }, .bool, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .@"test", .src1b, .si(1), ._, ._ },
                        .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .bt, .lea(.src0w), .ua(.src0, .add_vector_index), ._, ._ },
                        .{ ._, ._mp, .j, .@"0f", ._, ._, ._ },
                        .{ .@"1:", ._s, .bt, .lea(.src0w), .ua(.src0, .add_vector_index), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .ptr_any_bool_vec_elem, .bool, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .{ .imm = 0 }, .none } },
                    },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._r, .bt, .leaa(.src0d, .add_vector_index_div_8_down_4), .ua(.src0, .add_vector_index_rem_32), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .ptr_any_bool_vec_elem, .bool, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .{ .imm = 1 }, .none } },
                    },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._s, .bt, .leaa(.src0d, .add_vector_index_div_8_down_4), .ua(.src0, .add_vector_index_rem_32), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .ptr_any_bool_vec_elem, .bool, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .leaa(.src0d, .add_vector_index_div_8_down_4), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .bt, .tmp1d, .ua(.src0, .add_vector_index_rem_32), ._, ._ },
                        .{ ._, ._s, .bt, .tmp0d, .ua(.src0, .add_vector_index_rem_32), ._, ._ },
                        .{ ._, ._, .@"test", .src1b, .si(1), ._, ._ },
                        .{ ._, ._z, .cmov, .tmp0d, .tmp1d, ._, ._ },
                        .{ ._, ._, .mov, .leaa(.src0d, .add_vector_index_div_8_down_4), .tmp0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .ptr_any_bool_vec_elem, .bool, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .@"test", .src1b, .si(1), ._, ._ },
                        .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .bt, .leaa(.src0d, .add_vector_index_div_8_down_4), .ua(.src0, .add_vector_index_rem_32), ._, ._ },
                        .{ ._, ._mp, .j, .@"0f", ._, ._, ._ },
                        .{ .@"1:", ._s, .bt, .leaa(.src0d, .add_vector_index_div_8_down_4), .ua(.src0, .add_vector_index_rem_32), ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => try ops[0].store(&ops[1], .{
                        .disp = switch (cg.typeOf(bin_op.lhs).ptrInfo(zcu).flags.vector_index) {
                            .none => 0,
                            else => |vector_index| @intCast(cg.typeOf(bin_op.rhs).abiSize(zcu) * @intFromEnum(vector_index)),
                        },
                        .safe = switch (air_tag) {
                            else => unreachable,
                            .store => false,
                            .store_safe => true,
                        },
                    }, cg),
                    else => |e| return e,
                };
                for (ops) |op| try op.die(cg);
            },
            .unreach => {},
            .fptrunc => |air_tag| {
                const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                var res: [1]Temp = undefined;
                cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_, .cvtps2ph, .dst0q, .src0x, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_, .cvtps2ph, .dst0q, .src0x, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_, .cvtps2ph, .dst0x, .src0y, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__truncsfhf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ .@"0:", .v_ps, .mova, .tmp1y, .memsi(.src0y, .@"2", .tmp0), ._, ._ },
                        .{ ._, .v_, .cvtps2ph, .memi(.dst0x, .tmp0), .tmp1y, .rm(.{}), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__truncsfhf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memsi(.src0d, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__truncsfhf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ss, .mov, .tmp1x, .memsi(.src0d, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__truncsfhf2" } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ss, .mov, .tmp1x, .memsi(.src0d, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .tmp3d, .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__truncsfhf2" } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ss, .mov, .tmp1x, .memsi(.src0d, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .mem(.tmp3d), .tmp1x, ._, ._ },
                        .{ ._, ._, .mov, .tmp4d, .mem(.tmp3d), ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp4w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__truncdfhf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__truncdfhf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__truncdfhf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._sd, .mov, .tmp1x, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__truncdfhf2" } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._sd, .mov, .tmp1x, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .tmp3d, .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__truncdfhf2" } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._ps, .movl, .tmp1x, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .mem(.tmp3d), .tmp1x, ._, ._ },
                        .{ ._, ._, .mov, .tmp4d, .mem(.tmp3d), ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp4w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ },
                        .{ ._, .v_ss, .cvtsd2, .dst0x, .dst0x, .src0q, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ss, .cvtsd2, .dst0x, .src0x, .src0q, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ },
                        .{ ._, ._ss, .cvtsd2, .dst0x, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f64, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0q, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtpd2, .dst0x, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._ps, .cvtpd2, .dst0x, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtpd2, .dst0x, .src0y, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ .@"0:", .v_ps, .cvtpd2, .tmp1x, .memsi(.src0y, .@"2", .tmp0), ._, ._ },
                        .{ ._, .v_ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .cvtpd2, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._ps, .movl, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memsi(.src0q, .@"2", .tmp0), ._, ._, ._ },
                        .{ ._, .f_p, .st, .memi(.dst0d, .tmp0), ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__truncxfhf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, .v_dqa, .mov, .dst0x, .mem(.src0x), ._, ._ },
                        .{ ._, .v_dqa, .mov, .mem(.tmp0x), .dst0x, ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__truncxfhf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._dqa, .mov, .dst0x, .mem(.src0x), ._, ._ },
                        .{ ._, ._dqa, .mov, .mem(.tmp0x), .dst0x, ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__truncxfhf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._ps, .mova, .dst0x, .mem(.src0x), ._, ._ },
                        .{ ._, ._ps, .mova, .mem(.tmp0x), .dst0x, ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__truncxfhf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__truncxfhf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsi(.src0x, .@"8", .tmp0), ._, ._ },
                        .{ ._, .v_dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__truncxfhf2" } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__truncxfhf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memsi(.src0x, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__truncxfhf2" } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__truncxfhf2" } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memsi(.src0x, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .tmp4d, .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp4w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__truncxfhf2" } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .tmp4d, .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp4w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__truncxfhf2" } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memsi(.src0x, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._ps, .mova, .mem(.tmp2x), .tmp1x, ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp1x, ._, ._ },
                        .{ ._, ._, .mov, .tmp4d, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp4w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__truncxfhf2" } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .mem(.tmp4d), .tmp3x, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .mem(.tmp4d), ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp5w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_x87, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memsi(.src0t, .@"4", .tmp0), ._, ._, ._ },
                        .{ ._, .f_p, .st, .memi(.dst0d, .tmp0), ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_x87, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memsi(.src0t, .@"2", .tmp0), ._, ._, ._ },
                        .{ ._, .f_p, .st, .memi(.dst0q, .tmp0), ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__trunctfhf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__trunctfhf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__trunctfhf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsi(.src0x, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__trunctfhf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memsi(.src0x, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__trunctfhf2" } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memsi(.src0x, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .tmp3d, .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__trunctfhf2" } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memsi(.src0x, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .mem(.tmp3d), .tmp1x, ._, ._ },
                        .{ ._, ._, .mov, .tmp4d, .mem(.tmp3d), ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp4w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__trunctfhf2" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__trunctfhf2" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__trunctfhf2" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .tmp4d, .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp4w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__trunctfhf2" } },
                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .mem(.tmp4d), .tmp3x, ._, ._ },
                        .{ ._, ._, .mov, .tmp5d, .mem(.tmp4d), ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp5w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__trunctfsf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__trunctfsf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__trunctfsf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsi(.src0x, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__trunctfsf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memsi(.src0x, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__trunctfsf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memsi(.src0x, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__trunctfsf2" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__trunctfsf2" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__trunctfdf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__trunctfdf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__trunctfdf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_sd, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__trunctfdf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._sd, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__trunctfdf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ps, .movl, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__trunctfdf2" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_sd, .mov, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__trunctfdf2" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._sd, .mov, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__trunctfdf2" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ps, .movl, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, .x87, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__trunctfxf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .reg = .st0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__trunctfxf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__trunctfxf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .memi(.dst0t, .tmp0), ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__trunctfxf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .memi(.dst0t, .tmp0), ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__trunctfxf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sa(.dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .memi(.dst0t, .tmp0), ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__trunctfxf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.dst0, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f} {f}", .{
                        @tagName(air_tag),
                        ty_op.ty.toType().fmt(pt),
                        cg.typeOf(ty_op.operand).fmt(pt),
                        ops[0].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{ty_op.operand}, &ops, cg);
            },
            .fpext => |air_tag| {
                const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                var res: [1]Temp = undefined;
                cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__extendhfsf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ },
                        .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, .v_ps, .mova, .memsi(.dst0y, .@"2", .tmp0), .tmp1y, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__extendhfsf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_ss, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__extendhfsf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__extendhfsf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                        .{ ._, .v_sd, .cvtss2, .dst0x, .dst0x, .dst0d, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                        .{ ._, .v_pd, .cvtps2, .dst0x, .dst0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                        .{ ._, .v_pd, .cvtps2, .dst0y, .dst0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .zword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .tmp0y, .src0x, ._, ._ },
                        .{ ._, .v_pd, .cvtps2, .tmp1y, .tmp0x, ._, ._ },
                        .{ ._, .v_f128, .extract, .tmp0x, .tmp0y, .ui(1), ._ },
                        .{ ._, .v_pd, .mova, .mem(.dst0y), .tmp1y, ._, ._ },
                        .{ ._, .v_pd, .cvtps2, .tmp1y, .tmp0x, ._, ._ },
                        .{ ._, .v_pd, .mova, .memd(.dst0y, 32), .tmp1y, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__extendhfdf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .zword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ },
                        .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, .v_pd, .cvtps2, .tmp2y, .tmp1x, ._, ._ },
                        .{ ._, .v_f128, .extract, .tmp1x, .tmp1y, .ui(1), ._ },
                        .{ ._, .v_pd, .mova, .memsi(.dst0y, .@"4", .tmp0), .tmp2y, ._, ._ },
                        .{ ._, .v_pd, .cvtps2, .tmp2y, .tmp1x, ._, ._ },
                        .{ ._, .v_pd, .mova, .memsid(.dst0y, .@"4", .tmp0, 32), .tmp2y, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__extendhfdf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_sd, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__extendhfdf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._sd, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__extendhfdf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._ps, .movl, .memsi(.dst0q, .@"4", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, .x87, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f32, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .tmp0x, .src0q, ._, ._ },
                        .{ ._, .v_ss, .mov, .mem(.tmp1d), .tmp0x, ._, ._ },
                        .{ ._, .f_, .ld, .mem(.tmp1d), ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, .x87, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__extendhfxf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .reg = .st0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_reg = .xmm1 }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__extendhfxf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__extendhfxf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .memsi(.dst0t, .@"8", .tmp0), ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__extendhfxf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.dst0, .@"8", .tmp0), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ },
                        .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memi(.src0w, .tmp0), .ui(0) },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__extendhfxf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .memsi(.dst0t, .@"8", .tmp0), ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__extendhfxf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.dst0, .@"8", .tmp0), ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp2x, .memi(.src0w, .tmp0), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__extendhfxf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .memsi(.dst0t, .@"8", .tmp0), ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__extendhfxf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.dst0, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .movzx, .tmp2d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .mem(.tmp3d), .tmp2d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp3d), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__extendhftf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__extendhftf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"8", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__extendhftf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"8", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__extendhftf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memsi(.dst0x, .@"8", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ },
                        .{ ._, .v_sd, .cvtss2, .dst0x, .dst0x, .src0d, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_sd, .cvtss2, .dst0x, .src0x, .src0d, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ },
                        .{ ._, ._sd, .cvtss2, .dst0x, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f32, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0d, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_pd, .cvtps2, .dst0x, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._pd, .cvtps2, .dst0x, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_pd, .cvtps2, .dst0y, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ },
                        .{ .@"0:", .v_pd, .cvtps2, .tmp1y, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, .v_pd, .mova, .memsi(.dst0y, .@"2", .tmp0), .tmp1y, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
                        .{ .@"0:", ._pd, .cvtps2, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._pd, .mova, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memi(.src0d, .tmp0), ._, ._, ._ },
                        .{ ._, .f_p, .st, .memsi(.dst0q, .@"2", .tmp0), ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f32, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0d, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memi(.src0d, .tmp0), ._, ._, ._ },
                        .{ ._, .f_p, .st, .memsi(.dst0t, .@"4", .tmp0), ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__extendsftf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__extendsftf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__extendsftf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__extendsftf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f64, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0q, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memi(.src0q, .tmp0), ._, ._, ._ },
                        .{ ._, .f_p, .st, .memsi(.dst0t, .@"2", .tmp0), ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__extenddftf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__extenddftf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__extenddftf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__extenddftf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._ps, .movl, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__extendxftf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, .v_dqa, .mov, .dst0x, .mem(.src0x), ._, ._ },
                        .{ ._, .v_dqa, .mov, .mem(.tmp0x), .dst0x, ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__extendxftf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._dqa, .mov, .dst0x, .mem(.src0x), ._, ._ },
                        .{ ._, ._dqa, .mov, .mem(.tmp0x), .dst0x, ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__extendxftf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._ps, .mova, .dst0x, .mem(.src0x), ._, ._ },
                        .{ ._, ._ps, .mova, .mem(.tmp0x), .dst0x, ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__extendxftf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__extendxftf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, .v_dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__extendxftf2" } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__extendxftf2" } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__extendxftf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__extendxftf2" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._ps, .mova, .mem(.tmp2x), .tmp1x, ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__extendxftf2" } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f} {f}", .{
                        @tagName(air_tag),
                        ty_op.ty.toType().fmt(pt),
                        cg.typeOf(ty_op.operand).fmt(pt),
                        ops[0].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{ty_op.operand}, &ops, cg);
            },
            .intcast => |air_tag| {
                const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                const dst_ty = ty_op.ty.toType();
                const src_ty = cg.typeOf(ty_op.operand);
                var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                var res: [1]Temp = undefined;
                cg.select(&res, &.{dst_ty}, &ops, if (dst_ty.scalarType(zcu).abiSize(zcu) <= src_ty.scalarType(zcu).abiSize(zcu)) comptime &.{ .{
                    .dst_constraints = .{ .{ .int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{} },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .dst_constraints = .{ .{ .int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{} },
                }, .{
                    .dst_constraints = .{ .{ .int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0b, .mem(.src0b), ._, ._ },
                    } },
                }, .{
                    .dst_constraints = .{ .{ .int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0w, .mem(.src0w), ._, ._ },
                    } },
                }, .{
                    .dst_constraints = .{ .{ .int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0d, .mem(.src0d), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .dst_constraints = .{ .{ .int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0q, .mem(.src0q), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .dst_constraints = .{ .{ .remainder_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{} },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{} },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{} },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_b, .ackssw, .dst0x, .src0x, .dst0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_b, .ackusw, .dst0x, .src0x, .dst0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_b, .ackssw, .dst0x, .dst0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_b, .ackusw, .dst0x, .dst0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_i128, .extract, .dst0x, .src0y, .ui(1), ._ },
                        .{ ._, .vp_b, .ackssw, .dst0x, .src0x, .dst0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_f128, .extract, .dst0x, .src0y, .ui(1), ._ },
                        .{ ._, .vp_b, .ackssw, .dst0x, .src0x, .dst0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_i128, .extract, .dst0x, .src0y, .ui(1), ._ },
                        .{ ._, .vp_b, .ackusw, .dst0x, .src0x, .dst0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_f128, .extract, .dst0x, .src0y, .ui(1), ._ },
                        .{ ._, .vp_b, .ackusw, .dst0x, .src0x, .dst0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0w, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0w, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .ackssd, .dst0x, .src0x, .dst0x, ._ },
                        .{ ._, .vp_b, .ackssw, .dst0x, .dst0x, .dst0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .dword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .ackusd, .dst0x, .src0x, .dst0x, ._ },
                        .{ ._, .vp_b, .ackusw, .dst0x, .dst0x, .dst0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_w, .ackssd, .dst0x, .dst0x, ._, ._ },
                        .{ ._, .p_b, .ackssw, .dst0x, .dst0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .dword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_w, .ackusd, .dst0x, .dst0x, ._, ._ },
                        .{ ._, .p_b, .ackusw, .dst0x, .dst0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_i128, .extract, .dst0x, .src0y, .ui(1), ._ },
                        .{ ._, .vp_w, .ackssd, .dst0x, .src0x, .dst0x, ._ },
                        .{ ._, .vp_b, .ackssw, .dst0x, .dst0x, .dst0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_f128, .extract, .dst0x, .src0y, .ui(1), ._ },
                        .{ ._, .vp_w, .ackssd, .dst0x, .src0x, .dst0x, ._ },
                        .{ ._, .vp_b, .ackssw, .dst0x, .dst0x, .dst0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_i128, .extract, .dst0x, .src0y, .ui(1), ._ },
                        .{ ._, .vp_w, .ackusd, .dst0x, .src0x, .dst0x, ._ },
                        .{ ._, .vp_b, .ackusw, .dst0x, .dst0x, .dst0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_f128, .extract, .dst0x, .src0y, .ui(1), ._ },
                        .{ ._, .vp_w, .ackusd, .dst0x, .src0x, .dst0x, ._ },
                        .{ ._, .vp_b, .ackusw, .dst0x, .dst0x, .dst0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{ .any_scalar_int, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ },
                        .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .any_scalar_int, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ },
                        .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{} },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{} },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{} },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .ackssd, .dst0x, .src0x, .dst0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .ackusd, .dst0x, .src0x, .dst0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_w, .ackssd, .dst0x, .dst0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_w, .ackusd, .dst0x, .dst0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_i128, .extract, .dst0x, .src0y, .ui(1), ._ },
                        .{ ._, .vp_w, .ackssd, .dst0x, .src0x, .dst0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_f128, .extract, .dst0x, .src0y, .ui(1), ._ },
                        .{ ._, .vp_w, .ackssd, .dst0x, .src0x, .dst0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_i128, .extract, .dst0x, .src0y, .ui(1), ._ },
                        .{ ._, .vp_w, .ackusd, .dst0x, .src0x, .dst0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_f128, .extract, .dst0x, .src0y, .ui(1), ._ },
                        .{ ._, .vp_w, .ackusd, .dst0x, .src0x, .dst0x, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .any_scalar_int, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ },
                        .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{} },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{} },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{} },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .shuf, .dst0x, .src0x, .ui(0b10_00_10_00), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_d, .shuf, .dst0x, .src0x, .ui(0b10_00_10_00), ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .yword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .any_scalar_int, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ },
                        .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{} },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{} },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{} },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .any_scalar_int, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2q, .memi(.src0q, .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{} },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{} },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{} },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .yword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .yword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{} },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{ .any_scalar_int, .any, .any },
                    .dst_constraints = .{ .any_scalar_int, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp3d, .sa(.dst0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._, .add, .tmp1p, .sa2(.src0, .dst0, .add_delta_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .any_scalar_int, .any, .any },
                    .dst_constraints = .{ .any_scalar_int, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp3d, .sa(.dst0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._, .add, .tmp1p, .sa2(.src0, .dst0, .add_delta_elem_size), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                } } else comptime &.{ .{
                    .src_constraints = .{ .{ .signed_int = .byte }, .any, .any },
                    .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movsx, .dst0d, .src0b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .int = .byte }, .any, .any },
                    .dst_constraints = .{ .{ .int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .dst0d, .src0b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .signed_int = .byte }, .any, .any },
                    .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movsx, .dst0q, .src0b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .int = .byte }, .any, .any },
                    .dst_constraints = .{ .{ .int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .dst0d, .src0b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .signed_int = .byte }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .reg = .rax } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movsx, .tmp0q, .src0b, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._sq, .sto, ._, ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .int = .byte }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._sq, .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .byte }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i32, .kind = .{ .reg = .eax } },
                        .{ .type = .usize, .kind = .{ .reg = .edi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._sd, .sto, ._, ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0d, .ui(31), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_4), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .int = .byte }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .reg = .eax } },
                        .{ .type = .usize, .kind = .{ .reg = .edi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._sd, .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_4), ._, ._ },
                        .{ ._, .@"rep _sd", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .word }, .any, .any },
                    .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movsx, .dst0d, .src0w, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .int = .word }, .any, .any },
                    .dst_constraints = .{ .{ .int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .dst0d, .src0w, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .any, .any },
                    .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movsx, .dst0q, .src0w, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .int = .word }, .any, .any },
                    .dst_constraints = .{ .{ .int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .dst0d, .src0w, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .reg = .rax } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movsx, .tmp0q, .src0w, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._sq, .sto, ._, ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .int = .word }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._sq, .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .word }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i32, .kind = .{ .reg = .eax } },
                        .{ .type = .usize, .kind = .{ .reg = .edi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movsx, .tmp0d, .src0w, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._sd, .sto, ._, ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0d, .ui(31), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_4), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .int = .word }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .reg = .eax } },
                        .{ .type = .usize, .kind = .{ .reg = .edi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._sd, .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_4), ._, ._ },
                        .{ ._, .@"rep _sd", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .signed_int = .dword }, .any, .any },
                    .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._d, .movsx, .dst0q, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .int = .dword }, .any, .any },
                    .dst_constraints = .{ .{ .int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0d, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .signed_int = .dword }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .reg = .rax } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._d, .movsx, .tmp0q, .src0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._sq, .sto, ._, ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .int = .dword }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._sq, .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .dword }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i32, .kind = .{ .reg = .eax } },
                        .{ .type = .usize, .kind = .{ .reg = .edi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._sd, .sto, ._, ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0d, .ui(31), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_4), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .int = .dword }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .reg = .eax } },
                        .{ .type = .usize, .kind = .{ .reg = .edi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._sd, .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_4), ._, ._ },
                        .{ ._, .@"rep _sd", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .reg = .rax } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._sq, .sto, ._, ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .int = .qword }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._sq, .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .{ .type = .i64, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._sq, .lod, ._, ._, ._, ._ },
                        .{ ._, ._sq, .sto, ._, ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sa2(.dst0, .src0, .add_delta_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .remainder_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sa2(.dst0, .src0, .add_delta_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .movsxb, .dst0x, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .movzxb, .dst0x, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_w, .movsxb, .dst0x, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_w, .movzxb, .dst0x, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ },
                        .{ ._, .p_b, .cmpgt, .tmp0x, .src0x, ._, ._ },
                        .{ ._, .p_, .unpcklbw, .dst0x, .tmp0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpcklbw, .dst0x, .tmp0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .yword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .movsxb, .dst0y, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .movzxb, .dst0y, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_w, .movsxb, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_w, .movzxb, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_w, .movsxb, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_w, .movzxb, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_w, .movsxb, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_w, .movzxb, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .movsxb, .dst0x, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .movzxb, .dst0x, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_d, .movsxb, .dst0x, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_d, .movzxb, .dst0x, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ },
                        .{ ._, .p_b, .cmpgt, .tmp0x, .src0x, ._, ._ },
                        .{ ._, .p_, .unpcklbw, .dst0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpcklbw, .tmp0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpcklbw, .dst0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .movsxb, .dst0y, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .movzxb, .dst0y, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_d, .movsxb, .tmp1y, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"4", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_d, .movzxb, .tmp1y, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"4", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_d, .movsxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_d, .movzxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_d, .movsxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_d, .movzxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .word, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_q, .movsxb, .dst0x, .src0w, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .word, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_q, .movzxb, .dst0x, .src0w, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .word, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_q, .movsxb, .dst0x, .src0w, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .word, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_q, .movzxb, .dst0x, .src0w, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .word, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ },
                        .{ ._, .p_b, .cmpgt, .tmp0x, .src0x, ._, ._ },
                        .{ ._, .p_, .unpcklbw, .dst0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpcklbw, .tmp0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpcklwd, .tmp0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .word, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpcklbw, .dst0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_q, .movsxb, .dst0y, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_q, .movzxb, .dst0y, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_q, .movsxb, .tmp1y, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"8", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_q, .movzxb, .tmp1y, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"8", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_q, .movsxb, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_q, .movzxb, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_q, .movsxb, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_q, .movzxb, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1q, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1q, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_q, .movsxb, .dst0x, .src0w, ._, ._ },
                        .{ ._, .vp_q, .movsxd, .dst0x, .dst0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_q, .movzxb, .dst0x, .src0w, ._, ._ },
                        .{ ._, .vp_q, .movzxd, .dst0x, .dst0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_q, .movsxb, .dst0x, .src0w, ._, ._ },
                        .{ ._, .p_q, .movsxd, .dst0x, .dst0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_q, .movzxb, .dst0x, .src0w, ._, ._ },
                        .{ ._, .p_q, .movzxd, .dst0x, .dst0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ },
                        .{ ._, .p_b, .cmpgt, .tmp0x, .src0x, ._, ._ },
                        .{ ._, .p_, .unpcklbw, .dst0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpcklbw, .tmp0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpcklwd, .tmp0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpckldq, .tmp0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpcklqdq, .dst0x, .tmp0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpcklbw, .dst0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpcklqdq, .dst0x, .tmp0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .any_scalar_signed_int, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .i64, .kind = .{ .reg = .rax } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .mem(.dst0), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp2q, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._sq, .sto, ._, ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2q, .si(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .any_scalar_signed_int, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .i64, .kind = .{ .reg = .rax } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .mem(.dst0), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp2q, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._sq, .sto, ._, ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2q, .si(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .any_scalar_int, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .mem(.dst0), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._sq, .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .any_scalar_int, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .mem(.dst0), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._sq, .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .movsxw, .dst0x, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .movzxw, .dst0x, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_d, .movsxw, .dst0x, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_d, .movzxw, .dst0x, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ },
                        .{ ._, .p_w, .cmpgt, .tmp0x, .src0x, ._, ._ },
                        .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .movsxw, .dst0y, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .movzxw, .dst0y, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_d, .movsxw, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_d, .movzxw, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_d, .movsxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_d, .movzxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_d, .movsxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_d, .movzxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_q, .movsxw, .dst0x, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_q, .movzxw, .dst0x, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_q, .movsxw, .dst0x, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_q, .movzxw, .dst0x, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ },
                        .{ ._, .p_w, .cmpgt, .tmp0x, .src0x, ._, ._ },
                        .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpcklwd, .tmp0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_q, .movsxw, .dst0y, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_q, .movzxw, .dst0y, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_q, .movsxw, .tmp1y, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"4", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_q, .movzxw, .tmp1y, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"4", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_q, .movsxw, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_q, .movzxw, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_q, .movsxw, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_q, .movzxw, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1q, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_q, .movsxw, .dst0x, .src0d, ._, ._ },
                        .{ ._, .vp_q, .movsxd, .dst0x, .dst0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_q, .movzxw, .dst0x, .src0d, ._, ._ },
                        .{ ._, .vp_q, .movzxd, .dst0x, .dst0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_q, .movsxw, .dst0x, .src0d, ._, ._ },
                        .{ ._, .p_q, .movsxd, .dst0x, .dst0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_q, .movzxw, .dst0x, .src0d, ._, ._ },
                        .{ ._, .p_q, .movzxd, .dst0x, .dst0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ },
                        .{ ._, .p_w, .cmpgt, .tmp0x, .src0x, ._, ._ },
                        .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpcklwd, .tmp0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpckldq, .tmp0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpcklqdq, .dst0x, .tmp0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpcklqdq, .dst0x, .tmp0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .any_scalar_signed_int, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .i64, .kind = .{ .reg = .rax } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .mem(.dst0), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp2q, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._sq, .sto, ._, ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2q, .si(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .any_scalar_int, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .mem(.dst0), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._sq, .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_q, .movsxd, .dst0x, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_q, .movzxd, .dst0x, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_q, .movsxd, .dst0x, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_q, .movzxd, .dst0x, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ },
                        .{ ._, .p_d, .cmpgt, .tmp0x, .src0x, ._, ._ },
                        .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_q, .movsxd, .dst0y, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_q, .movzxd, .dst0y, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_q, .movsxd, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_q, .movzxd, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_q, .movsxd, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_q, .movzxd, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_q, .movsxd, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_q, .movzxd, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._d, .movsx, .tmp1q, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_q, .movsxd, .dst0x, .src0q, ._, ._ },
                        .{ ._, .vp_q, .movsxd, .dst0x, .dst0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_q, .movzxd, .dst0x, .src0q, ._, ._ },
                        .{ ._, .vp_q, .movzxd, .dst0x, .dst0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_q, .movsxd, .dst0x, .src0q, ._, ._ },
                        .{ ._, .p_q, .movsxd, .dst0x, .dst0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_q, .movzxd, .dst0x, .src0q, ._, ._ },
                        .{ ._, .p_q, .movzxd, .dst0x, .dst0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ },
                        .{ ._, .p_d, .cmpgt, .tmp0x, .src0x, ._, ._ },
                        .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpckldq, .tmp0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpcklqdq, .dst0x, .tmp0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ },
                        .{ ._, .p_, .unpcklqdq, .dst0x, .tmp0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .any_scalar_signed_int, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .i64, .kind = .{ .reg = .rax } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .mem(.dst0), ._, ._ },
                        .{ .@"0:", ._d, .movsx, .tmp2q, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._sq, .sto, ._, ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2q, .si(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .any_scalar_int, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .mem(.dst0), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._sq, .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{ .any_scalar_signed_int, .any, .any },
                    .dst_constraints = .{ .any_scalar_signed_int, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .{ .type = .i64, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp3d, .sia(-1, .src0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._sq, .lod, ._, ._, ._, ._ },
                        .{ ._, ._sq, .sto, ._, ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp4q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa2(.dst0, .src0, .add_delta_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .any_scalar_signed_int, .any, .any },
                    .dst_constraints = .{ .any_scalar_signed_int, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .{ .type = .i64, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp3d, .sia(-1, .src0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._sq, .lod, ._, ._, ._, ._ },
                        .{ ._, ._sq, .sto, ._, ._, ._, ._ },
                        .{ ._, ._r, .sa, .tmp4q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa2(.dst0, .src0, .add_delta_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{ .any_scalar_int, .any, .any },
                    .dst_constraints = .{ .any_scalar_int, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp3d, .sa(.src0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa2(.dst0, .src0, .add_delta_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .any_scalar_int, .any, .any },
                    .dst_constraints = .{ .any_scalar_int, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp3d, .sa(.src0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa2(.dst0, .src0, .add_delta_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f} {f}", .{
                        @tagName(air_tag),
                        dst_ty.fmt(pt),
                        src_ty.fmt(pt),
                        ops[0].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{ty_op.operand}, &ops, cg);
            },
            .intcast_safe => unreachable,
            .trunc => |air_tag| {
                const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                var res: [1]Temp = undefined;
                cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{
                    .src_constraints = .{ .{ .signed_int = .gpr }, .any, .any },
                    .dst_constraints = .{ .{ .exact_signed_int = 1 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .@"and", .dst0d, .si(1), ._, ._ },
                        .{ ._, ._, .neg, .dst0d, ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .any_signed_int, .any, .any },
                    .dst_constraints = .{ .{ .exact_signed_int = 1 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .dst0d, .mem(.src0b), ._, ._ },
                        .{ ._, ._, .@"and", .dst0d, .si(1), ._, ._ },
                        .{ ._, ._, .neg, .dst0d, ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .int = .gpr }, .any, .any },
                    .dst_constraints = .{ .{ .exact_int = 8 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{} },
                }, .{
                    .src_constraints = .{ .any_signed_int, .any, .any },
                    .dst_constraints = .{ .{ .exact_signed_int = 8 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movsx, .dst0d, .mem(.src0b), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .any_unsigned_int, .any, .any },
                    .dst_constraints = .{ .{ .exact_unsigned_int = 8 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .dst0d, .mem(.src0b), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .gpr }, .any, .any },
                    .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._l, .sa, .dst0b, .uia(8, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .dst0b, .uia(8, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .gpr }, .any, .any },
                    .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .@"and", .dst0b, .sa(.dst0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .any_int, .any, .any },
                    .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .dst0d, .mem(.src0b), ._, ._ },
                        .{ ._, ._, .@"and", .dst0b, .sa(.dst0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .int = .gpr }, .any, .any },
                    .dst_constraints = .{ .{ .exact_int = 16 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{} },
                }, .{
                    .src_constraints = .{ .any_signed_int, .any, .any },
                    .dst_constraints = .{ .{ .exact_signed_int = 16 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movsx, .dst0d, .mem(.src0w), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .any_unsigned_int, .any, .any },
                    .dst_constraints = .{ .{ .exact_unsigned_int = 16 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .dst0d, .mem(.src0w), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .gpr }, .any, .any },
                    .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .@"and", .dst0w, .sa(.dst0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{ .any_unsigned_int, .any, .any },
                    .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .dst0d, .mem(.src0w), ._, ._ },
                        .{ ._, ._, .@"and", .dst0w, .sa(.dst0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .int = .gpr }, .any, .any },
                    .dst_constraints = .{ .{ .exact_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_mem, .none, .none } },
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{} },
                }, .{
                    .src_constraints = .{ .any_int, .any, .any },
                    .dst_constraints = .{ .{ .exact_int = 32 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0d, .mem(.src0d), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .gpr }, .any, .any },
                    .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._l, .sa, .dst0d, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .dst0d, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .any_signed_int, .any, .any },
                    .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0d, .mem(.src0d), ._, ._ },
                        .{ ._, ._l, .sa, .dst0d, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .dst0d, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .gpr }, .any, .any },
                    .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .@"and", .dst0d, .sa(.dst0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .any_unsigned_int, .any, .any },
                    .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0d, .mem(.src0d), ._, ._ },
                        .{ ._, ._, .@"and", .dst0d, .sa(.dst0, .add_umax), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .any_int, .any, .any },
                    .dst_constraints = .{ .{ .exact_int = 64 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0q, .mem(.src0q), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .signed_int = .gpr }, .any, .any },
                    .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._l, .sa, .dst0q, .uia(64, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .dst0q, .uia(64, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .any_signed_int, .any, .any },
                    .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0q, .mem(.src0q), ._, ._ },
                        .{ ._, ._l, .sa, .dst0q, .uia(64, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .dst0q, .uia(64, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .gpr }, .any, .any },
                    .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .bzhi, .dst0q, .src0q, .dst0q, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, null, null },
                    .src_constraints = .{ .any_unsigned_int, .any, .any },
                    .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .bzhi, .dst0q, .mem(.src0q), .dst0q, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .gpr }, .any, .any },
                    .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0q, .ua(.dst0, .add_umax), ._, ._ },
                        .{ ._, ._, .@"and", .dst0q, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .any_unsigned_int, .any, .any },
                    .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0q, .ua(.dst0, .add_umax), ._, ._ },
                        .{ ._, ._, .@"and", .dst0q, .mem(.src0q), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .any_int, .any, .any },
                    .dst_constraints = .{ .{ .exact_remainder_int = .{ .of = .xword, .is = 128 } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .any_signed_int, .any, .any },
                    .dst_constraints = .{ .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 64 } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .memad(.src0q, .add_dst0_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp0q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .any_signed_int, .any, .any },
                    .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .memad(.src0q, .add_dst0_size, -16), ._, ._ },
                        .{ ._, ._l, .sa, .tmp0q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp0q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .any_signed_int, .any, .any },
                    .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .memad(.src0q, .add_dst0_size, -8), ._, ._ },
                        .{ ._, ._l, .sa, .tmp0q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .any_unsigned_int, .any, .any },
                    .dst_constraints = .{ .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, null, null },
                    .src_constraints = .{ .any_unsigned_int, .any, .any },
                    .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .bzhi, .tmp2q, .memad(.src0q, .add_dst0_size, -16), .tmp2q, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp2q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, null, null },
                    .src_constraints = .{ .any_unsigned_int, .any, .any },
                    .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .bzhi, .tmp2q, .memad(.src0q, .add_dst0_size, -8), .tmp2q, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp2q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .any_unsigned_int, .any, .any },
                    .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .ua(.dst0, .add_umax), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0q, .memad(.src0q, .add_dst0_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .any_unsigned_int, .any, .any },
                    .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .ua(.dst0, .add_umax), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0q, .memad(.src0q, .add_dst0_size, -8), ._, ._ },
                        .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                        .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                        .{ ._, .vp_b, .add, .dst0x, .dst0x, .lea(.tmp0x), ._ },
                        .{ ._, .vp_, .xor, .dst0x, .dst0x, .lea(.tmp0x), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                        .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                        .{ ._, .p_b, .add, .dst0x, .lea(.tmp0x), ._, ._ },
                        .{ ._, .p_, .xor, .dst0x, .lea(.tmp0x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._ps, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .yword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                        .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                        .{ ._, .vp_b, .add, .dst0y, .dst0y, .lea(.tmp0y), ._ },
                        .{ ._, .vp_, .xor, .dst0y, .dst0y, .lea(.tmp0y), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                        .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp4), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp1y, .lea(.tmp0y), ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp5), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp2y, .lea(.tmp0y), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .@"and", .tmp3y, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .vp_b, .add, .tmp3y, .tmp3y, .tmp2y, ._ },
                        .{ ._, .vp_, .xor, .tmp3y, .tmp3y, .tmp2y, ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp3y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp1y, .lea(.tmp0y), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .@"and", .tmp2y, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp2y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                        .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp4), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp5), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .@"and", .tmp3x, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .vp_b, .add, .tmp3x, .tmp3x, .tmp2x, ._ },
                        .{ ._, .vp_, .xor, .tmp3x, .tmp3x, .tmp2x, ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .@"and", .tmp2x, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                        .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp4), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp5), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp3x, .tmp1x, ._, ._ },
                        .{ ._, .p_, .@"and", .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_b, .add, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ },
                        .{ ._, .p_, .@"and", .tmp2x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                        .{ ._, ._ps, .mova, .tmp1x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp2x, .tmp1x, ._, ._ },
                        .{ ._, ._ps, .@"and", .tmp2x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 1 } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1b, .si(1), ._, ._ },
                        .{ ._, ._, .neg, .tmp1b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 1 } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1b, .si(1), ._, ._ },
                        .{ ._, ._, .neg, .tmp1b, ._, ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._l, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._l, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1b, .sa(.dst0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1b, .sa(.dst0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0b, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0b, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memsia(.src0b, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._l, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memsia(.src0b, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._l, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0b, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1b, .sa(.dst0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0b, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1b, .sa(.dst0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._l, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._l, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi2, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1b, .sa(.dst0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1b, .sa(.dst0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._l, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._l, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi2, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), .tmp1d, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), .tmp1d, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1b, .sa(.dst0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1b, .sa(.dst0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{ .any_scalar_int, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ },
                        .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .any_scalar_int, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ },
                        .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{ .any_scalar_signed_int, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ },
                        .{ ._, ._l, .sa, .tmp2b, .uia(8, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp2b, .uia(8, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ },
                        .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .any_scalar_signed_int, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ },
                        .{ ._, ._l, .sa, .tmp2b, .uia(8, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp2b, .uia(8, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ },
                        .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi2, .slow_incdec, null, null },
                    .src_constraints = .{ .any_scalar_unsigned_int, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ .@"0:", ._, .bzhi, .tmp3d, .memi(.src0d, .tmp1), .tmp2d, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ },
                        .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi2, null, null, null },
                    .src_constraints = .{ .any_scalar_unsigned_int, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ .@"0:", ._, .bzhi, .tmp3d, .memi(.src0d, .tmp1), .tmp2d, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ },
                        .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{ .any_scalar_unsigned_int, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ },
                        .{ ._, ._, .@"and", .tmp2b, .sa(.dst0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ },
                        .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .any_scalar_unsigned_int, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ },
                        .{ ._, ._, .@"and", .tmp2b, .sa(.dst0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ },
                        .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .sll, .dst0x, .src0x, .uia(16, .dst0, .sub_bit_size), ._ },
                        .{ ._, .vp_w, .sra, .dst0x, .dst0x, .uia(16, .dst0, .sub_bit_size), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_w, .sll, .dst0x, .uia(16, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, .p_w, .sra, .dst0x, .uia(16, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._ps, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .yword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .yword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .sll, .dst0y, .src0y, .uia(16, .dst0, .sub_bit_size), ._ },
                        .{ ._, .vp_w, .sra, .dst0y, .dst0y, .uia(16, .dst0, .sub_bit_size), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .yword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .yword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .sll, .tmp1y, .tmp1y, .uia(16, .dst0, .sub_bit_size), ._ },
                        .{ ._, .vp_w, .sra, .tmp1y, .tmp1y, .uia(16, .dst0, .sub_bit_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp1y, .lea(.tmp0y), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .@"and", .tmp2y, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp2y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_w, .sll, .tmp1x, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._ },
                        .{ ._, .vp_w, .sra, .tmp1x, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .@"and", .tmp2x, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_w, .sll, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, .p_w, .sra, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ },
                        .{ ._, .p_, .@"and", .tmp2x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                        .{ ._, ._ps, .mova, .tmp1x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp2x, .tmp1x, ._, ._ },
                        .{ ._, ._ps, .@"and", .tmp2x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_exact_int = .{ .of = .word, .is = 16 } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._l, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1w, .sa(.dst0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1d, .sa(.dst0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_exact_int = .{ .of = .word, .is = 16 } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._l, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), .tmp1d, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1w, .sa(.dst0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1d, .sa(.dst0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_exact_int = .{ .of = .word, .is = 16 } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._l, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1w, .sa(.dst0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1d, .sa(.dst0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_exact_int = .{ .of = .word, .is = 16 } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._l, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), .tmp1d, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1w, .sa(.dst0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1d, .sa(.dst0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .any_scalar_int, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_exact_int = .{ .of = .word, .is = 16 } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ },
                        .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .any_scalar_signed_int, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ },
                        .{ ._, ._l, .sa, .tmp2d, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp2d, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ },
                        .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi2, null, null, null },
                    .src_constraints = .{ .any_scalar_unsigned_int, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ .@"0:", ._, .bzhi, .tmp3d, .memi(.src0d, .tmp1), .tmp2d, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ },
                        .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fast_imm16, null, null, null },
                    .src_constraints = .{ .any_scalar_unsigned_int, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ },
                        .{ ._, ._, .@"and", .tmp2w, .sa(.dst0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ },
                        .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .any_scalar_unsigned_int, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ },
                        .{ ._, ._, .@"and", .tmp2d, .sa(.dst0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ },
                        .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .sll, .dst0x, .src0x, .uia(32, .dst0, .sub_bit_size), ._ },
                        .{ ._, .vp_d, .sra, .dst0x, .dst0x, .uia(32, .dst0, .sub_bit_size), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_d, .sll, .dst0x, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, .p_d, .sra, .dst0x, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._ps, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .sll, .dst0y, .src0y, .uia(32, .dst0, .sub_bit_size), ._ },
                        .{ ._, .vp_d, .sra, .dst0y, .dst0y, .uia(32, .dst0, .sub_bit_size), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_d, .sll, .tmp1y, .tmp1y, .uia(32, .dst0, .sub_bit_size), ._ },
                        .{ ._, .vp_d, .sra, .tmp1y, .tmp1y, .uia(32, .dst0, .sub_bit_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp1y, .lea(.tmp0y), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .@"and", .tmp2y, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp2y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .vp_d, .sll, .tmp1x, .tmp1x, .uia(32, .dst0, .sub_bit_size), ._ },
                        .{ ._, .vp_d, .sra, .tmp1x, .tmp1x, .uia(32, .dst0, .sub_bit_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .@"and", .tmp2x, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_d, .sll, .tmp1x, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, .p_d, .sra, .tmp1x, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ },
                        .{ ._, .p_, .@"and", .tmp2x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                        .{ ._, ._ps, .mova, .tmp1x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp2x, .tmp1x, ._, ._ },
                        .{ ._, ._ps, .@"and", .tmp2x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_exact_int = .{ .of = .dword, .is = 32 } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._l, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ .@"0:", ._, .bzhi, .tmp2d, .memia(.src0d, .tmp0, .add_unaligned_size), .tmp1d, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1d, .sa(.dst0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_exact_int = .{ .of = .dword, .is = 32 } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._l, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), .tmp1d, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1d, .sa(.dst0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_exact_int = .{ .of = .dword, .is = 32 } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._l, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1d, .sa(.dst0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .yword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_exact_int = .{ .of = .dword, .is = 32 } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .yword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._l, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .yword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), .tmp1d, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .yword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1d, .sa(.dst0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .any_scalar_int, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_exact_int = .{ .of = .dword, .is = 32 } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ },
                        .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .any_scalar_signed_int, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ },
                        .{ ._, ._l, .sa, .tmp2d, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp2d, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ },
                        .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .bmi2, null, null, null },
                    .src_constraints = .{ .any_scalar_unsigned_int, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ .@"0:", ._, .bzhi, .tmp3d, .memi(.src0d, .tmp1), .tmp2d, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ },
                        .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .any_scalar_unsigned_int, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ },
                        .{ ._, ._, .@"and", .tmp2d, .sa(.dst0, .add_umax), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ },
                        .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                        .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                        .{ ._, .vp_q, .add, .dst0x, .dst0x, .lea(.tmp0x), ._ },
                        .{ ._, .vp_, .xor, .dst0x, .dst0x, .lea(.tmp0x), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                        .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                        .{ ._, .p_q, .add, .dst0x, .lea(.tmp0x), ._, ._ },
                        .{ ._, .p_, .xor, .dst0x, .lea(.tmp0x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._ps, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                        .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                        .{ ._, .vp_q, .add, .dst0y, .dst0y, .lea(.tmp0y), ._ },
                        .{ ._, .vp_, .xor, .dst0y, .dst0y, .lea(.tmp0y), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                        .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp4), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp1y, .lea(.tmp0y), ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp5), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp2y, .lea(.tmp0y), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .@"and", .tmp3y, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .vp_q, .add, .tmp3y, .tmp3y, .tmp2y, ._ },
                        .{ ._, .vp_, .xor, .tmp3y, .tmp3y, .tmp2y, ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp3y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp1y, .lea(.tmp0y), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .@"and", .tmp2y, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp2y, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                        .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp4), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp5), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .@"and", .tmp3x, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .vp_q, .add, .tmp3x, .tmp3x, .tmp2x, ._ },
                        .{ ._, .vp_, .xor, .tmp3x, .tmp3x, .tmp2x, ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .@"and", .tmp2x, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._ },
                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                        .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp4), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp5), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp3x, .tmp1x, ._, ._ },
                        .{ ._, .p_, .@"and", .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, .p_q, .add, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ },
                        .{ ._, .p_, .@"and", .tmp2x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                        .{ ._, ._ps, .mova, .tmp1x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp2x, .tmp1x, ._, ._ },
                        .{ ._, ._ps, .@"and", .tmp2x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_exact_int = .{ .of = .qword, .is = 64 } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._l, .sa, .tmp1q, .uia(64, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .uia(64, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ .@"0:", ._, .bzhi, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), .tmp1q, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .ua(.dst0, .add_umax), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_exact_int = .{ .of = .qword, .is = 64 } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._l, .sa, .tmp1q, .uia(64, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .uia(64, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ .@"0:", ._, .bzhi, .tmp2q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), .tmp1q, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .ua(.dst0, .add_umax), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .yword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_exact_int = .{ .of = .qword, .is = 64 } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .yword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._l, .sa, .tmp1q, .uia(64, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .uia(64, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .yword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ .@"0:", ._, .bzhi, .tmp2q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), .tmp1q, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .yword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .ua(.dst0, .add_umax), ._, ._ },
                        .{ ._, ._, .@"and", .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .any_scalar_int, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_exact_int = .{ .of = .qword, .is = 64 } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2q, .memi(.src0q, .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .any_scalar_signed_int, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2q, .memi(.src0q, .tmp1), ._, ._ },
                        .{ ._, ._l, .sa, .tmp2q, .uia(64, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._r, .sa, .tmp2q, .uia(64, .dst0, .sub_bit_size), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, null, null },
                    .src_constraints = .{ .any_scalar_unsigned_int, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ .@"0:", ._, .bzhi, .tmp3q, .memi(.src0q, .tmp1), .tmp2q, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .any_scalar_unsigned_int, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2q, .ua(.dst0, .add_umax), ._, ._ },
                        .{ ._, ._, .@"and", .tmp2q, .memi(.src0q, .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{ .any_scalar_int, .any, .any },
                    .dst_constraints = .{ .{ .scalar_exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp3d, .sa(.dst0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._, .add, .tmp1p, .sa2(.src0, .dst0, .add_delta_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .any_scalar_int, .any, .any },
                    .dst_constraints = .{ .{ .scalar_exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp3d, .sa(.dst0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._, .add, .tmp1p, .sa2(.src0, .dst0, .add_delta_elem_size), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{ .any_scalar_signed_int, .any, .any },
                    .dst_constraints = .{ .{ .scalar_exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp3d, .sia(-2, .dst0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp1q), ._, ._ },
                        .{ ._, ._, .mov, .lea(.tmp2q), .tmp3q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .lead(.tmp2q, 8), .tmp3q, ._, ._ },
                        .{ ._, ._, .add, .tmp1p, .sia2(16, .src0, .dst0, .add_delta_elem_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .lead(.tmp2, 16), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .any_scalar_signed_int, .any, .any },
                    .dst_constraints = .{ .{ .scalar_exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp3d, .sia(-2, .dst0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp1q), ._, ._ },
                        .{ ._, ._, .mov, .lea(.tmp2q), .tmp3q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .lead(.tmp2q, 8), .tmp3q, ._, ._ },
                        .{ ._, ._, .add, .tmp1p, .sia2(16, .src0, .dst0, .add_delta_elem_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .lead(.tmp2, 16), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{ .any_scalar_signed_int, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp3d, .sia(-2, .dst0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp1q), ._, ._ },
                        .{ ._, ._l, .sa, .tmp3q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .lea(.tmp2q), .tmp3q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .lead(.tmp2q, 8), .tmp3q, ._, ._ },
                        .{ ._, ._, .add, .tmp1p, .sia2(16, .src0, .dst0, .add_delta_elem_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .lead(.tmp2, 16), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .any_scalar_signed_int, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp3d, .sia(-2, .dst0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .lea(.tmp1q), ._, ._ },
                        .{ ._, ._l, .sa, .tmp3q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._, .mov, .lea(.tmp2q), .tmp3q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .lead(.tmp2q, 8), .tmp3q, ._, ._ },
                        .{ ._, ._, .add, .tmp1p, .sia2(16, .src0, .dst0, .add_delta_elem_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .lead(.tmp2, 16), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{ .any_scalar_signed_int, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp3d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .lea(.tmp1q), ._, ._ },
                        .{ ._, ._l, .sa, .tmp4q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp4q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._sq, .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .any_scalar_signed_int, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp3d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .lea(.tmp1q), ._, ._ },
                        .{ ._, ._l, .sa, .tmp4q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._r, .sa, .tmp4q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ },
                        .{ ._, ._sq, .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{ .any_scalar_unsigned_int, .any, .any },
                    .dst_constraints = .{ .{ .scalar_exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp4d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._sq, .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .add, .tmp1p, .sa2(.src0, .dst0, .add_delta_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .any_scalar_unsigned_int, .any, .any },
                    .dst_constraints = .{ .{ .scalar_exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp4d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._sq, .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .add, .tmp1p, .sa2(.src0, .dst0, .add_delta_elem_size), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, .slow_incdec, null },
                    .src_constraints = .{ .any_scalar_unsigned_int, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size_rem_64), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp4d, .sia(-2, .dst0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._, .bzhi, .tmp4q, .lea(.tmp1q), .tmp3q, ._ },
                        .{ ._, ._, .mov, .lea(.tmp2q), .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .lead(.tmp2q, 8), .si(0), ._, ._ },
                        .{ ._, ._, .add, .tmp1p, .sia2(16, .src0, .dst0, .add_delta_elem_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .lead(.tmp2, 16), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, null, null },
                    .src_constraints = .{ .any_scalar_unsigned_int, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size_rem_64), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp4d, .sia(-2, .dst0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._, .bzhi, .tmp4q, .lea(.tmp1q), .tmp3q, ._ },
                        .{ ._, ._, .mov, .lea(.tmp2q), .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .lead(.tmp2q, 8), .si(0), ._, ._ },
                        .{ ._, ._, .add, .tmp1p, .sia2(16, .src0, .dst0, .add_delta_elem_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .lead(.tmp2, 16), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, .slow_incdec, null },
                    .src_constraints = .{ .any_scalar_unsigned_int, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size_rem_64), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp4d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._, .bzhi, .tmp5q, .lea(.tmp1q), .tmp3q, ._ },
                        .{ ._, ._sq, .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .bmi2, null, null },
                    .src_constraints = .{ .any_scalar_unsigned_int, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size_rem_64), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp4d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._, .bzhi, .tmp5q, .lea(.tmp1q), .tmp3q, ._ },
                        .{ ._, ._sq, .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{ .any_scalar_unsigned_int, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp3d, .sia(-2, .dst0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .ua(.dst0, .add_umax), ._, ._ },
                        .{ ._, ._, .@"and", .tmp3q, .lea(.tmp1q), ._, ._ },
                        .{ ._, ._, .mov, .lea(.tmp2q), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .lead(.tmp2q, 8), .si(0), ._, ._ },
                        .{ ._, ._, .add, .tmp1p, .sia2(16, .src0, .dst0, .add_delta_elem_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .lead(.tmp2, 16), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .any_scalar_unsigned_int, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp3d, .sia(-2, .dst0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3q, .ua(.dst0, .add_umax), ._, ._ },
                        .{ ._, ._, .@"and", .tmp3q, .lea(.tmp1q), ._, ._ },
                        .{ ._, ._, .mov, .lea(.tmp2q), .tmp3q, ._, ._ },
                        .{ ._, ._, .mov, .lead(.tmp2q, 8), .si(0), ._, ._ },
                        .{ ._, ._, .add, .tmp1p, .sia2(16, .src0, .dst0, .add_delta_elem_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .lead(.tmp2, 16), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .src_constraints = .{ .any_scalar_unsigned_int, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp4d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .ua(.dst0, .add_umax), ._, ._ },
                        .{ ._, ._, .@"and", .tmp4q, .lea(.tmp1q), ._, ._ },
                        .{ ._, ._sq, .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .any_scalar_unsigned_int, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp4d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp4q, .ua(.dst0, .add_umax), ._, ._ },
                        .{ ._, ._, .@"and", .tmp4q, .lea(.tmp1q), ._, ._ },
                        .{ ._, ._sq, .sto, ._, ._, ._, ._ },
                        .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f} {f}", .{
                        @tagName(air_tag),
                        ty_op.ty.toType().fmt(pt),
                        cg.typeOf(ty_op.operand).fmt(pt),
                        ops[0].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{ty_op.operand}, &ops, cg);
            },
            .optional_payload => {
                const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                const pl = if (!hack_around_sema_opv_bugs or ty_op.ty.toType().hasRuntimeBitsIgnoreComptime(zcu))
                    try ops[0].read(ty_op.ty.toType(), .{}, cg)
                else
                    try cg.tempInit(ty_op.ty.toType(), .none);
                try pl.finish(inst, &.{ty_op.operand}, &ops, cg);
            },
            .optional_payload_ptr => {
                const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                const ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg);
            },
            .optional_payload_ptr_set => {
                const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                const opt_ty = cg.typeOf(ty_op.operand).childType(zcu);
                var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                if (!opt_ty.optionalReprIsPayload(zcu)) {
                    const opt_pl_ty = opt_ty.optionalChild(zcu);
                    const opt_pl_abi_size: i32 = @intCast(opt_pl_ty.abiSize(zcu));
                    try ops[0].toOffset(opt_pl_abi_size, cg);
                    var has_value = try cg.tempInit(.bool, .{ .immediate = 1 });
                    try ops[0].store(&has_value, .{}, cg);
                    try has_value.die(cg);
                    try ops[0].toOffset(-opt_pl_abi_size, cg);
                }
                try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg);
            },
            .wrap_optional => {
                const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                const opt_ty = ty_op.ty.toType();
                const opt_pl_ty = cg.typeOf(ty_op.operand);
                const opt_pl_abi_size: u31 = @intCast(opt_pl_ty.abiSize(zcu));
                var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                var opt = try cg.tempAlloc(opt_ty);
                try opt.write(&ops[0], .{}, cg);
                if (!opt_ty.optionalReprIsPayload(zcu)) {
                    var has_value = try cg.tempInit(.bool, .{ .immediate = 1 });
                    try opt.write(&has_value, .{ .disp = opt_pl_abi_size }, cg);
                    try has_value.die(cg);
                }
                try opt.finish(inst, &.{ty_op.operand}, &ops, cg);
            },
            .unwrap_errunion_payload => {
                const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                const eu_pl_ty = ty_op.ty.toType();
                const eu_pl_off: i32 = @intCast(codegen.errUnionPayloadOffset(eu_pl_ty, zcu));
                var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                const pl = if (!hack_around_sema_opv_bugs or eu_pl_ty.hasRuntimeBitsIgnoreComptime(zcu))
                    try ops[0].read(eu_pl_ty, .{ .disp = eu_pl_off }, cg)
                else
                    try cg.tempInit(eu_pl_ty, .none);
                try pl.finish(inst, &.{ty_op.operand}, &ops, cg);
            },
            .unwrap_errunion_err => {
                const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                const eu_ty = cg.typeOf(ty_op.operand);
                const eu_err_ty = ty_op.ty.toType();
                const eu_pl_ty = eu_ty.errorUnionPayload(zcu);
                const eu_err_off: i32 = @intCast(codegen.errUnionErrorOffset(eu_pl_ty, zcu));
                var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                const err = try ops[0].read(eu_err_ty, .{ .disp = eu_err_off }, cg);
                try err.finish(inst, &.{ty_op.operand}, &ops, cg);
            },
            .unwrap_errunion_payload_ptr => {
                const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                const eu_ty = cg.typeOf(ty_op.operand).childType(zcu);
                const eu_pl_ty = eu_ty.errorUnionPayload(zcu);
                const eu_pl_off: i32 = @intCast(codegen.errUnionPayloadOffset(eu_pl_ty, zcu));
                var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                try ops[0].toOffset(eu_pl_off, cg);
                try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg);
            },
            .unwrap_errunion_err_ptr => {
                const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                const eu_ty = cg.typeOf(ty_op.operand).childType(zcu);
                const eu_err_ty = ty_op.ty.toType();
                const eu_pl_ty = eu_ty.errorUnionPayload(zcu);
                const eu_err_off: i32 = @intCast(codegen.errUnionErrorOffset(eu_pl_ty, zcu));
                var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                try ops[0].toOffset(eu_err_off, cg);
                const err = try ops[0].load(eu_err_ty, .{}, cg);
                try err.finish(inst, &.{ty_op.operand}, &ops, cg);
            },
            .errunion_payload_ptr_set => {
                const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                const eu_ty = cg.typeOf(ty_op.operand).childType(zcu);
                const eu_err_ty = eu_ty.errorUnionSet(zcu);
                const eu_pl_ty = eu_ty.errorUnionPayload(zcu);
                const eu_err_off: i32 = @intCast(codegen.errUnionErrorOffset(eu_pl_ty, zcu));
                const eu_pl_off: i32 = @intCast(codegen.errUnionPayloadOffset(eu_pl_ty, zcu));
                var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                try ops[0].toOffset(eu_err_off, cg);
                var err = try cg.tempInit(eu_err_ty, .{ .immediate = 0 });
                try ops[0].store(&err, .{}, cg);
                try err.die(cg);
                try ops[0].toOffset(eu_pl_off - eu_err_off, cg);
                try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg);
            },
            .wrap_errunion_payload => {
                const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                const eu_ty = ty_op.ty.toType();
                const eu_err_ty = eu_ty.errorUnionSet(zcu);
                const eu_pl_ty = cg.typeOf(ty_op.operand);
                const eu_err_off: u31 = @intCast(codegen.errUnionErrorOffset(eu_pl_ty, zcu));
                const eu_pl_off: u31 = @intCast(codegen.errUnionPayloadOffset(eu_pl_ty, zcu));
                var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                var eu = try cg.tempAlloc(eu_ty);
                try eu.write(&ops[0], .{ .disp = eu_pl_off }, cg);
                var err = try cg.tempInit(eu_err_ty, .{ .immediate = 0 });
                try eu.write(&err, .{ .disp = eu_err_off }, cg);
                try err.die(cg);
                try eu.finish(inst, &.{ty_op.operand}, &ops, cg);
            },
            .wrap_errunion_err => {
                const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                const eu_ty = ty_op.ty.toType();
                const eu_pl_ty = eu_ty.errorUnionPayload(zcu);
                const eu_err_off: u31 = @intCast(codegen.errUnionErrorOffset(eu_pl_ty, zcu));
                var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                var eu = try cg.tempAlloc(eu_ty);
                try eu.write(&ops[0], .{ .disp = eu_err_off }, cg);
                try eu.finish(inst, &.{ty_op.operand}, &ops, cg);
            },
            .struct_field_ptr => {
                const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
                const struct_field = cg.air.extraData(Air.StructField, ty_pl.payload).data;
                var ops = try cg.tempsFromOperands(inst, .{struct_field.struct_operand});
                try ops[0].toOffset(@intCast(codegen.fieldOffset(
                    cg.typeOf(struct_field.struct_operand),
                    ty_pl.ty.toType(),
                    struct_field.field_index,
                    zcu,
                )), cg);
                try ops[0].finish(inst, &.{struct_field.struct_operand}, &ops, cg);
            },
            .struct_field_ptr_index_0,
            .struct_field_ptr_index_1,
            .struct_field_ptr_index_2,
            .struct_field_ptr_index_3,
            => |air_tag| {
                const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                try ops[0].toOffset(@intCast(codegen.fieldOffset(
                    cg.typeOf(ty_op.operand),
                    ty_op.ty.toType(),
                    switch (air_tag) {
                        else => unreachable,
                        .struct_field_ptr_index_0 => 0,
                        .struct_field_ptr_index_1 => 1,
                        .struct_field_ptr_index_2 => 2,
                        .struct_field_ptr_index_3 => 3,
                    },
                    zcu,
                )), cg);
                try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg);
            },
            .struct_field_val => {
                const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
                const struct_field = cg.air.extraData(Air.StructField, ty_pl.payload).data;
                const agg_ty = cg.typeOf(struct_field.struct_operand);
                const field_ty = ty_pl.ty.toType();
                const field_off: u31 = switch (agg_ty.containerLayout(zcu)) {
                    .auto, .@"extern" => @intCast(agg_ty.structFieldOffset(struct_field.field_index, zcu)),
                    .@"packed" => unreachable,
                };
                var ops = try cg.tempsFromOperands(inst, .{struct_field.struct_operand});
                var res = if (!hack_around_sema_opv_bugs or field_ty.hasRuntimeBitsIgnoreComptime(zcu))
                    try ops[0].read(field_ty, .{ .disp = field_off }, cg)
                else
                    try cg.tempInit(field_ty, .none);
                try res.finish(inst, &.{struct_field.struct_operand}, &ops, cg);
            },
            .set_union_tag => {
                const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                const union_ty = cg.typeOf(bin_op.lhs).childType(zcu);
                const union_layout = union_ty.unionGetLayout(zcu);
                var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                if (!hack_around_sema_opv_bugs or union_layout.tag_size > 0) try ops[0].store(&ops[1], .{
                    .disp = @intCast(union_layout.tagOffset()),
                }, cg);
                const res = try cg.tempInit(.void, .none);
                try res.finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
            },
            .get_union_tag => {
                const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                const union_ty = cg.typeOf(ty_op.operand);
                var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                const union_layout = union_ty.unionGetLayout(zcu);
                assert(union_layout.tag_size > 0);
                const res = try ops[0].read(ty_op.ty.toType(), .{
                    .disp = @intCast(union_layout.tagOffset()),
                }, cg);
                try res.finish(inst, &.{ty_op.operand}, &ops, cg);
            },
            .slice => {
                const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
                const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data;
                var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                try ops[0].toPair(&ops[1], cg);
                try ops[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
            },
            .slice_len => {
                const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                try ops[0].toSliceLen(cg);
                try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg);
            },
            .slice_ptr => {
                const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                try ops[0].toSlicePtr(cg);
                try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg);
            },
            .ptr_slice_len_ptr => {
                const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                try ops[0].toOffset(8, cg);
                try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg);
            },
            .ptr_slice_ptr_ptr => {
                const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                try ops[0].toOffset(0, cg);
                try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg);
            },
            .array_elem_val, .legalize_vec_elem_val => {
                const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                const array_ty = cg.typeOf(bin_op.lhs);
                const res_ty = array_ty.elemType2(zcu);
                var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                var res: [1]Temp = undefined;
                cg.select(&res, &.{res_ty}, &ops, comptime &.{ .{
                    .src_constraints = .{ .{ .bool_vec = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .imm32, .none } },
                    },
                    .dst_temps = .{ .{ .cc = .c }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .bt, .src0d, .ua(.none, .add_src1), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .bool_vec = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .cc = .c }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .bt, .src0d, .src1d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .bool_vec = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .imm32, .none } },
                    },
                    .dst_temps = .{ .{ .cc = .c }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .bt, .src0q, .ua(.none, .add_src1), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .bool_vec = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .cc = .c }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .bt, .src0q, .src1q, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .any_bool_vec, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .imm32, .none } },
                    },
                    .dst_temps = .{ .{ .cc = .c }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .bt, .mema(.src0d, .add_src1_div_8_down_4), .ua(.none, .add_src1_rem_32), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .any_bool_vec, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .cc = .c }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .bt, .src0d, .src1d, ._, ._ },
                    } },
                }, .{
                    .dst_constraints = .{ .{ .int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .simm32, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .dst0d, .mema(.src0b, .add_src0_elem_size_mul_src1), ._, ._ },
                    } },
                }, .{
                    .dst_constraints = .{ .{ .int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .dst0d, .memi(.src0b, .src1), ._, ._ },
                    } },
                }, .{
                    .dst_constraints = .{ .{ .int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .simm32, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .dst0d, .mema(.src0w, .add_src0_elem_size_mul_src1), ._, ._ },
                    } },
                }, .{
                    .dst_constraints = .{ .{ .int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .dst0d, .memsi(.src0w, .@"2", .src1), ._, ._ },
                    } },
                }, .{
                    .dst_constraints = .{ .{ .int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .simm32, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0d, .mema(.src0d, .add_src0_elem_size_mul_src1), ._, ._ },
                    } },
                }, .{
                    .dst_constraints = .{ .{ .int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0d, .memsi(.src0d, .@"4", .src1), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .dst_constraints = .{ .{ .int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .simm32, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0q, .mema(.src0q, .add_src0_elem_size_mul_src1), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .dst_constraints = .{ .{ .int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0q, .memsi(.src0q, .@"8", .src1), ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => {
                        const elem_size = res_ty.abiSize(zcu);
                        var base = try cg.tempAllocReg(.usize, abi.RegisterClass.gp);
                        while (try ops[0].toBase(false, cg) or
                            try ops[1].toRegClass(true, .general_purpose, cg) or
                            try base.toRegClass(true, .general_purpose, cg))
                        {}
                        const base_reg = base.tracking(cg).short.register.to64();
                        const rhs_reg = ops[1].tracking(cg).short.register.to64();
                        if (!std.math.isPowerOfTwo(elem_size)) {
                            try cg.spillEflagsIfOccupied();
                            try cg.asmRegisterRegisterImmediate(
                                .{ .i_, .mul },
                                rhs_reg,
                                rhs_reg,
                                .u(elem_size),
                            );
                            try cg.asmRegisterMemory(
                                .{ ._, .lea },
                                base_reg,
                                try ops[0].tracking(cg).short.mem(cg, .{ .index = rhs_reg }),
                            );
                        } else if (elem_size > 8) {
                            try cg.spillEflagsIfOccupied();
                            try cg.asmRegisterImmediate(
                                .{ ._l, .sh },
                                rhs_reg,
                                .u(std.math.log2_int(u64, elem_size)),
                            );
                            try cg.asmRegisterMemory(
                                .{ ._, .lea },
                                base_reg,
                                try ops[0].tracking(cg).short.mem(cg, .{ .index = rhs_reg }),
                            );
                        } else try cg.asmRegisterMemory(
                            .{ ._, .lea },
                            base_reg,
                            try ops[0].tracking(cg).short.mem(cg, .{
                                .index = rhs_reg,
                                .scale = .fromFactor(@intCast(elem_size)),
                            }),
                        );
                        // Hack around Sema insanity: lhs could be an arbitrarily large comptime-known array
                        // which could easily get spilled by the upcoming `load`, which would infinite recurse
                        // since spilling an array requires the same operation that triggered the spill.
                        try ops[0].die(cg);
                        ops[0] = base;
                        res[0] = try ops[0].load(res_ty, .{}, cg);
                    },
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
            },
            .slice_elem_val, .ptr_elem_val => {
                const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                const res_ty = cg.typeOf(bin_op.lhs).elemType2(zcu);
                var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                try ops[0].toSlicePtr(cg);
                var res: [1]Temp = undefined;
                if (!hack_around_sema_opv_bugs or res_ty.hasRuntimeBitsIgnoreComptime(zcu)) cg.select(&res, &.{res_ty}, &ops, comptime &.{ .{
                    .dst_constraints = .{ .{ .int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .simm32, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .dst0d, .leaa(.src0b, .add_src0_elem_size_mul_src1), ._, ._ },
                    } },
                }, .{
                    .dst_constraints = .{ .{ .int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .dst0d, .leai(.src0b, .src1), ._, ._ },
                    } },
                }, .{
                    .dst_constraints = .{ .{ .int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .simm32, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .dst0d, .leaa(.src0w, .add_src0_elem_size_mul_src1), ._, ._ },
                    } },
                }, .{
                    .dst_constraints = .{ .{ .int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .dst0d, .leasi(.src0w, .@"2", .src1), ._, ._ },
                    } },
                }, .{
                    .dst_constraints = .{ .{ .int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .simm32, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0d, .leaa(.src0d, .add_src0_elem_size_mul_src1), ._, ._ },
                    } },
                }, .{
                    .dst_constraints = .{ .{ .int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0d, .leasi(.src0d, .@"4", .src1), ._, ._ },
                    } },
                }, .{
                    .dst_constraints = .{ .{ .int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .simm32, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0q, .leaa(.src0q, .add_src0_elem_size_mul_src1), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .dst_constraints = .{ .{ .int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .dst0q, .leasi(.src0q, .@"8", .src1), ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => {
                        const elem_size = res_ty.abiSize(zcu);
                        while (true) for (&ops) |*op| {
                            if (try op.toRegClass(true, .general_purpose, cg)) break;
                        } else break;
                        const lhs_reg = ops[0].tracking(cg).short.register.to64();
                        const rhs_reg = ops[1].tracking(cg).short.register.to64();
                        if (!std.math.isPowerOfTwo(elem_size)) {
                            try cg.spillEflagsIfOccupied();
                            try cg.asmRegisterRegisterImmediate(
                                .{ .i_, .mul },
                                rhs_reg,
                                rhs_reg,
                                .u(elem_size),
                            );
                            try cg.asmRegisterMemory(.{ ._, .lea }, lhs_reg, .{
                                .base = .{ .reg = lhs_reg },
                                .mod = .{ .rm = .{ .index = rhs_reg } },
                            });
                        } else if (elem_size > 8) {
                            try cg.spillEflagsIfOccupied();
                            try cg.asmRegisterImmediate(
                                .{ ._l, .sh },
                                rhs_reg,
                                .u(std.math.log2_int(u64, elem_size)),
                            );
                            try cg.asmRegisterMemory(.{ ._, .lea }, lhs_reg, .{
                                .base = .{ .reg = lhs_reg },
                                .mod = .{ .rm = .{ .index = rhs_reg } },
                            });
                        } else try cg.asmRegisterMemory(.{ ._, .lea }, lhs_reg, .{
                            .base = .{ .reg = lhs_reg },
                            .mod = .{ .rm = .{
                                .index = rhs_reg,
                                .scale = .fromFactor(@intCast(elem_size)),
                            } },
                        });
                        res[0] = try ops[0].load(res_ty, .{}, cg);
                    },
                    else => |e| return e,
                } else res[0] = try cg.tempInit(res_ty, .none);
                try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
            },
            .slice_elem_ptr, .ptr_elem_ptr => {
                const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
                const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data;
                var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                try ops[0].toSlicePtr(cg);
                const dst_ty = ty_pl.ty.toType();
                if (dst_ty.ptrInfo(zcu).flags.vector_index == .none) zero_offset: {
                    const elem_size = dst_ty.childType(zcu).abiSize(zcu);
                    if (hack_around_sema_opv_bugs and elem_size == 0) break :zero_offset;
                    while (true) for (&ops) |*op| {
                        if (try op.toRegClass(true, .general_purpose, cg)) break;
                    } else break;
                    const lhs_reg = ops[0].tracking(cg).short.register.to64();
                    const rhs_reg = ops[1].tracking(cg).short.register.to64();
                    if (!std.math.isPowerOfTwo(elem_size)) {
                        try cg.spillEflagsIfOccupied();
                        try cg.asmRegisterRegisterImmediate(
                            .{ .i_, .mul },
                            rhs_reg,
                            rhs_reg,
                            .u(elem_size),
                        );
                        try cg.asmRegisterMemory(.{ ._, .lea }, lhs_reg, .{
                            .base = .{ .reg = lhs_reg },
                            .mod = .{ .rm = .{ .index = rhs_reg } },
                        });
                    } else if (elem_size > 8) {
                        try cg.spillEflagsIfOccupied();
                        try cg.asmRegisterImmediate(
                            .{ ._l, .sh },
                            rhs_reg,
                            .u(std.math.log2_int(u64, elem_size)),
                        );
                        try cg.asmRegisterMemory(.{ ._, .lea }, lhs_reg, .{
                            .base = .{ .reg = lhs_reg },
                            .mod = .{ .rm = .{ .index = rhs_reg } },
                        });
                    } else try cg.asmRegisterMemory(.{ ._, .lea }, lhs_reg, .{
                        .base = .{ .reg = lhs_reg },
                        .mod = .{ .rm = .{
                            .index = rhs_reg,
                            .scale = .fromFactor(@intCast(elem_size)),
                        } },
                    });
                }
                try ops[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
            },
            .array_to_slice => {
                const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                var len = try cg.tempInit(.usize, .{
                    .immediate = cg.typeOf(ty_op.operand).childType(zcu).arrayLen(zcu),
                });
                try ops[0].toPair(&len, cg);
                try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg);
            },
            .int_from_float, .int_from_float_optimized => |air_tag| {
                const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                var res: [1]Temp = undefined;
                cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .float = .word }, .any, .any },
                    .dst_constraints = .{ .{ .int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .tmp0x, .src0q, ._, ._ },
                        .{ ._, .v_, .cvttss2si, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .f16c, null, null },
                    .src_constraints = .{ .{ .float = .word }, .any, .any },
                    .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .tmp0x, .src0q, ._, ._ },
                        .{ ._, .v_, .cvttss2si, .dst0q, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .f16c, null, null },
                    .src_constraints = .{ .{ .float = .word }, .any, .any },
                    .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .tmp0x, .src0q, ._, ._ },
                        .{ ._, .v_, .cvttss2si, .dst0d, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .f16c, null, null },
                    .src_constraints = .{ .{ .float = .word }, .any, .any },
                    .dst_constraints = .{ .{ .signed_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .tmp0x, .src0q, ._, ._ },
                        .{ ._, .v_, .cvttss2si, .tmp1q, .tmp0d, ._, ._ },
                        .{ ._, ._, .mov, .dst0q, .tmp1q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .f16c, null, null },
                    .src_constraints = .{ .{ .float = .word }, .any, .any },
                    .dst_constraints = .{ .{ .unsigned_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .tmp0x, .src0q, ._, ._ },
                        .{ ._, .v_, .cvttss2si, .tmp1q, .tmp0d, ._, ._ },
                        .{ ._, ._, .mov, .dst0q, .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .memd(.dst0q, 8), .si(0), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .f16c, null, null },
                    .src_constraints = .{ .{ .float = .word }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .{ .type = .i64, .kind = .{ .reg = .rax } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .tmp0x, .src0q, ._, ._ },
                        .{ ._, .v_, .cvttss2si, .tmp1q, .tmp0d, ._, ._ },
                        .{ ._, ._, .mov, .dst0q, .tmp1q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.dst0, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .f16c, null, null },
                    .src_constraints = .{ .{ .float = .word }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .{ .type = .i64, .kind = .{ .reg = .rax } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .tmp0x, .src0q, ._, ._ },
                        .{ ._, .v_, .cvttss2si, .tmp1q, .tmp0d, ._, ._ },
                        .{ ._, ._, .mov, .dst0q, .tmp1q, ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.dst0, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .float = .word }, .any, .any },
                    .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixhfsi" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .float = .word }, .any, .any },
                    .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfsi" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .float = .word }, .any, .any },
                    .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixhfdi" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .float = .word }, .any, .any },
                    .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfdi" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .float = .word }, .any, .any },
                    .dst_constraints = .{ .{ .signed_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixhfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .float = .word }, .any, .any },
                    .dst_constraints = .{ .{ .signed_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixhfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .float = .word }, .any, .any },
                    .dst_constraints = .{ .{ .unsigned_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .float = .word }, .any, .any },
                    .dst_constraints = .{ .{ .unsigned_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .float = .word }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixhfdi" } },
                        .{ .type = .i64, .kind = .{ .reg = .rax } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0q, .tmp1q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.dst0, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .float = .word }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfdi" } },
                        .{ .type = .i64, .kind = .{ .reg = .rax } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0q, .tmp1q, ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.dst0, 8), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .dword, .to = .byte } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                        .{ ._, .v_, .cvttps2dq, .dst0x, .dst0x, ._, ._ },
                        .{ ._, .vp_b, .shuf, .dst0x, .dst0x, .lea(.tmp0x), ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .dword, .to = .byte } } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_ps, .mova, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_size), ._, ._ },
                        .{ .@"0:", .v_ps, .cvtph2, .tmp3x, .memsi(.src0q, .@"2", .tmp0), ._, ._ },
                        .{ ._, .v_, .cvttps2dq, .tmp3x, .tmp3x, ._, ._ },
                        .{ ._, .vp_b, .shuf, .tmp3x, .tmp3x, .tmp2x, ._ },
                        .{ ._, .v_d, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixhfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memsi(.src0w, .@"2", .tmp0), .ui(0) },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixhfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memsi(.src0w, .@"2", .tmp0), .ui(0) },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixhfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memsi(.src0w, .@"2", .tmp0), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixhfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memsi(.src0w, .@"2", .tmp0), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixhfsi" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memsi(.src0w, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp1b, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixhfsi" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memsi(.src0w, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp1b, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                        .{ ._, .v_, .cvttps2dq, .dst0x, .dst0x, ._, ._ },
                        .{ ._, .vp_w, .ackssd, .dst0x, .dst0x, .dst0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                        .{ ._, .v_, .cvttps2dq, .dst0x, .dst0x, ._, ._ },
                        .{ ._, .vp_w, .ackusd, .dst0x, .dst0x, .dst0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
                        .{ .@"0:", .v_ps, .cvtph2, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, .v_, .cvttps2dq, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .vp_w, .ackssd, .tmp1x, .tmp1x, .tmp1x, ._ },
                        .{ ._, .v_q, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
                        .{ .@"0:", .v_ps, .cvtph2, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, .v_, .cvttps2dq, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .vp_w, .ackusd, .tmp1x, .tmp1x, .tmp1x, ._ },
                        .{ ._, .v_q, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixhfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixhfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixhfsi" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
                        .{ .@"0:", .v_ps, .cvtph2, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, .v_, .cvttps2dq, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .rc = .sse } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                        .{ ._, .v_ps, .cvtph2, .tmp1x, .tmp1q, ._, ._ },
                        .{ ._, .v_, .cvttss2si, .tmp2q, .tmp1x, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp2d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixhfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfsi" } },
                        .{ .type = .u32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixhfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfsi" } },
                        .{ .type = .u32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixhfsi" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp1d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfsi" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp1d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .f16c, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .rc = .sse } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                        .{ ._, .v_ps, .cvtph2, .tmp1x, .tmp1q, ._, ._ },
                        .{ ._, .v_, .cvttss2si, .tmp2q, .tmp1x, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp2q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixhfdi" } },
                        .{ .type = .i64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfdi" } },
                        .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixhfdi" } },
                        .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfdi" } },
                        .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixhfdi" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp1q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfdi" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp1q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixhfti" } },
                        .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q0, ._, ._ },
                        .{ ._, ._, .mov, .memsid(.dst0q, .@"8", .tmp0, 8), .tmp3q1, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixhfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"8", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfti" } },
                        .{ .type = .u128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q0, ._, ._ },
                        .{ ._, ._, .mov, .memsid(.dst0q, .@"8", .tmp0, 8), .tmp3q1, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"8", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixhfti" } },
                        .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q0, ._, ._ },
                        .{ ._, ._, .mov, .memsid(.dst0q, .@"8", .tmp0, 8), .tmp3q1, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixhfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"8", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfti" } },
                        .{ .type = .u128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q0, ._, ._ },
                        .{ ._, ._, .mov, .memsid(.dst0q, .@"8", .tmp0, 8), .tmp3q1, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"8", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixhfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d0, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d0, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp1q0, ._, ._ },
                        .{ ._, ._, .mov, .memsid(.dst0q, .@"8", .tmp0, 8), .tmp1q1, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixhfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memsi(.dst0x, .@"8", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d0, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d0, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp1q0, ._, ._ },
                        .{ ._, ._, .mov, .memsid(.dst0q, .@"8", .tmp0, 8), .tmp1q1, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memsi(.dst0x, .@"8", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixhfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ .@"0:", .v_ps, .xor, .tmp4x, .tmp4x, .tmp4x, ._ },
                        .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, .vp_w, .insr, .tmp4x, .tmp4x, .memi(.src0w, .tmp0), .ui(0) },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ .@"0:", .v_ps, .xor, .tmp4x, .tmp4x, .tmp4x, ._ },
                        .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, .vp_w, .insr, .tmp4x, .tmp4x, .memi(.src0w, .tmp0), .ui(0) },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse2, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixhfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ .@"0:", ._ps, .xor, .tmp4x, .tmp4x, ._, ._ },
                        .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, .p_w, .insr, .tmp4x, .memi(.src0w, .tmp0), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse2, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ .@"0:", ._ps, .xor, .tmp4x, .tmp4x, ._, ._ },
                        .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, .p_w, .insr, .tmp4x, .memi(.src0w, .tmp0), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixhfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp3d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                        .{ ._, ._, .mov, .tmp4d, .tmp3d, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, ._ss, .mov, .tmp5x, .tmp4d, ._, ._ },
                        .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp3d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                        .{ ._, ._, .mov, .tmp4d, .tmp3d, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, ._ss, .mov, .tmp5x, .tmp4d, ._, ._ },
                        .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .float = .dword }, .any, .any },
                    .dst_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_, .cvttss2si, .dst0d, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .float = .dword }, .any, .any },
                    .dst_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cvttss2si, .dst0d, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{ .{ .float = .dword }, .any, .any },
                    .dst_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_, .cvttss2si, .dst0q, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .float = .dword }, .any, .any },
                    .dst_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cvttss2si, .dst0q, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{ .{ .float = .dword }, .any, .any },
                    .dst_constraints = .{ .{ .exact_unsigned_int = 64 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .@"0x1p63_mem" = .{} } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp3), ._, ._ },
                        .{ ._, .v_, .cvttss2si, .tmp2q, .src0d, ._, ._ },
                        .{ ._, .v_ss, .sub, .tmp0x, .src0x, .lea(.tmp1d), ._ },
                        .{ ._, .v_, .cvttss2si, .dst0q, .tmp0d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .tmp2q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"and", .dst0q, .tmp2q, ._, ._ },
                        .{ ._, ._, .@"or", .dst0q, .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .float = .dword }, .any, .any },
                    .dst_constraints = .{ .{ .exact_unsigned_int = 64 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .@"0x1p63_mem" = .{} } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                        .{ ._, ._, .cvttss2si, .tmp1q, .src0d, ._, ._ },
                        .{ ._, ._ss, .sub, .src0x, .lea(.tmp0d), ._, ._ },
                        .{ ._, ._, .cvttss2si, .dst0q, .src0d, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"and", .dst0q, .tmp1q, ._, ._ },
                        .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .float = .dword }, .any, .any },
                    .dst_constraints = .{ .{ .signed_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixsfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .float = .dword }, .any, .any },
                    .dst_constraints = .{ .{ .signed_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixsfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .float = .dword }, .any, .any },
                    .dst_constraints = .{ .{ .unsigned_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .float = .dword }, .any, .any },
                    .dst_constraints = .{ .{ .unsigned_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .float = .dword }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .reg = .rax } },
                        .{ .type = .vector_4_f32, .kind = .{ .smax_mem = .{} } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } },
                        .{ .type = .i64, .kind = .{ .reg = .rdx } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, .v_d, .mov, .tmp0d, .src0x, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ },
                        .{ ._, ._d, .movsx, .tmp0q, .tmp0d, ._, ._ },
                        .{ ._, .v_ps, .@"and", .src0x, .src0x, .lea(.tmp1x), ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .xor, .tmp4q, .tmp0q, ._, ._ },
                        .{ ._, ._, .sub, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .mem(.dst0q), .tmp1q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp4q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp4q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .tmp1q, ._, ._ },
                        .{ ._, ._, .lea, .tmp5p, .memd(.dst0, 16), ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .float = .dword }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .reg = .rax } },
                        .{ .type = .vector_4_f32, .kind = .{ .smax_mem = .{} } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } },
                        .{ .type = .i64, .kind = .{ .reg = .rdx } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, .v_d, .mov, .tmp0d, .src0x, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ },
                        .{ ._, ._d, .movsx, .tmp0q, .tmp0d, ._, ._ },
                        .{ ._, .v_ps, .@"and", .src0x, .src0x, .lea(.tmp1x), ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .v_q, .mov, .tmp1q, .src0x, ._, ._ },
                        .{ ._, .vp_q, .extr, .tmp4q, .src0x, .ui(1), ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .xor, .tmp4q, .tmp0q, ._, ._ },
                        .{ ._, ._, .sub, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .mem(.dst0q), .tmp1q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp4q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp4q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .tmp1q, ._, ._ },
                        .{ ._, ._, .lea, .tmp5p, .memd(.dst0, 16), ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .float = .dword }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .reg = .rax } },
                        .{ .type = .vector_4_f32, .kind = .{ .smax_mem = .{} } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } },
                        .{ .type = .i64, .kind = .{ .reg = .rdx } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._d, .mov, .tmp0d, .src0x, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ },
                        .{ ._, ._d, .movsx, .tmp0q, .tmp0d, ._, ._ },
                        .{ ._, ._ps, .@"and", .src0x, .lea(.tmp1x), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .xor, .tmp4q, .tmp0q, ._, ._ },
                        .{ ._, ._, .sub, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .mem(.dst0q), .tmp1q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp4q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp4q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .tmp1q, ._, ._ },
                        .{ ._, ._, .lea, .tmp5p, .memd(.dst0, 16), ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .float = .dword }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .reg = .rax } },
                        .{ .type = .vector_4_f32, .kind = .{ .smax_mem = .{} } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } },
                        .{ .type = .i64, .kind = .{ .reg = .rdx } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._d, .mov, .tmp0d, .src0x, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ },
                        .{ ._, ._d, .movsx, .tmp0q, .tmp0d, ._, ._ },
                        .{ ._, ._ps, .@"and", .src0x, .lea(.tmp1x), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._q, .mov, .tmp1q, .src0x, ._, ._ },
                        .{ ._, .p_q, .extr, .tmp4q, .src0x, .ui(1), ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .xor, .tmp4q, .tmp0q, ._, ._ },
                        .{ ._, ._, .sub, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .mem(.dst0q), .tmp1q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp4q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp4q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .tmp1q, ._, ._ },
                        .{ ._, ._, .lea, .tmp5p, .memd(.dst0, 16), ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .float = .dword }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .reg = .rax } },
                        .{ .type = .vector_4_f32, .kind = .{ .smax_mem = .{} } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } },
                        .{ .type = .i64, .kind = .{ .reg = .rdx } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._d, .mov, .tmp0d, .src0x, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ },
                        .{ ._, ._d, .movsx, .tmp0q, .tmp0d, ._, ._ },
                        .{ ._, ._ps, .@"and", .src0x, .lea(.tmp1x), ._, ._ },
                        .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._q, .mov, .tmp1q, .src0x, ._, ._ },
                        .{ ._, .p_d, .shuf, .src0x, .src0x, .ui(0b11_10), ._ },
                        .{ ._, ._q, .mov, .tmp4q, .src0x, ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .xor, .tmp4q, .tmp0q, ._, ._ },
                        .{ ._, ._, .sub, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .mem(.dst0q), .tmp1q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp4q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp4q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .tmp1q, ._, ._ },
                        .{ ._, ._, .lea, .tmp5p, .memd(.dst0, 16), ._, ._ },
                        .{ ._, ._, .mov, .tmp6d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .float = .dword }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .i64, .kind = .{ .reg = .rax } },
                        .{ .type = .vector_4_f32, .kind = .{ .smax_mem = .{} } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .{ .type = .i64, .kind = .{ .reg = .rdx } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._ss, .mov, .tmp0x, .src0d, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ },
                        .{ ._, ._ps, .@"and", .tmp0x, .lea(.tmp1x), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._d, .movsx, .tmp4q, .src0d, ._, ._ },
                        .{ ._, ._r, .sa, .tmp4q, .ui(63), ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .tmp4q, ._, ._ },
                        .{ ._, ._, .xor, .tmp5q, .tmp4q, ._, ._ },
                        .{ ._, ._, .sub, .tmp1q, .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .mem(.dst0q), .tmp1q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp5q, .tmp4q, ._, ._ },
                        .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp5q, ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .tmp1q, ._, ._ },
                        .{ ._, ._, .lea, .tmp6p, .memd(.dst0, 16), ._, ._ },
                        .{ ._, ._, .mov, .tmp4d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .float = .dword }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .mem(.dst0x), .src0x, ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.dst0, 16), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .float = .dword }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .mem(.dst0x), .src0x, ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.dst0, 16), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .float = .dword }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } },
                        .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                        .{ ._, ._, .mov, .mem(.dst0q), .tmp1q0, ._, ._ },
                        .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp1q1, ._, ._ },
                        .{ ._, ._, .xor, .tmp1d0, .tmp1d0, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.dst0, 16), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .float = .dword }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } },
                        .{ .type = .u64, .kind = .{ .reg = .rax } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .u32, .kind = .{ .reg = .ecx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .mem(.dst0x), .src0x, ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memd(.dst0, 16), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .dword, .to = .byte } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_, .cvttps2dq, .dst0x, .src0x, ._, ._ },
                        .{ ._, .vp_b, .shuf, .dst0x, .dst0x, .lea(.tmp0x), ._ },
                    } },
                }, .{
                    .required_features = .{ .ssse3, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .dword, .to = .byte } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._, .cvttps2dq, .dst0x, .src0x, ._, ._ },
                        .{ ._, .p_b, .shuf, .dst0x, .lea(.tmp0x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .dword, .to = .byte } } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_size), ._, ._ },
                        .{ .@"0:", .v_, .cvttps2dq, .tmp3x, .memsi(.src0x, .@"4", .tmp0), ._, ._ },
                        .{ ._, .vp_b, .shuf, .tmp3x, .tmp3x, .tmp2x, ._ },
                        .{ ._, .v_d, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .ssse3, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .dword, .to = .byte } } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .cvttps2dq, .tmp3x, .memsi(.src0x, .@"4", .tmp0), ._, ._ },
                        .{ ._, .p_b, .shuf, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, ._d, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .cvttss2si, .tmp1d, .memsi(.src0d, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp1b, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .cvttss2si, .tmp1d, .memsi(.src0d, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp1b, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixsfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memsi(.src0d, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixsfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memsi(.src0d, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixsfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ss, .mov, .tmp1x, .memsi(.src0d, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixsfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ss, .mov, .tmp1x, .memsi(.src0d, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_, .cvttps2dq, .dst0x, .src0x, ._, ._ },
                        .{ ._, .vp_w, .ackssd, .dst0x, .dst0x, .dst0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cvttps2dq, .dst0x, .src0x, ._, ._ },
                        .{ ._, .p_w, .ackssd, .dst0x, .dst0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_, .cvttps2dq, .dst0x, .src0x, ._, ._ },
                        .{ ._, .vp_w, .ackusd, .dst0x, .dst0x, .dst0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cvttps2dq, .dst0x, .src0x, ._, ._ },
                        .{ ._, .p_w, .ackusd, .dst0x, .dst0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ },
                        .{ .@"0:", .v_, .cvttps2dq, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ },
                        .{ ._, .vp_w, .ackssd, .tmp1x, .tmp1x, .tmp1x, ._ },
                        .{ ._, .v_q, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .cvttps2dq, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ },
                        .{ ._, .p_w, .ackssd, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._q, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ },
                        .{ .@"0:", .v_, .cvttps2dq, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ },
                        .{ ._, .vp_w, .ackusd, .tmp1x, .tmp1x, .tmp1x, ._ },
                        .{ ._, .v_q, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .cvttps2dq, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ },
                        .{ ._, .p_w, .ackusd, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._q, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixsfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memsi(.src0d, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixsfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ss, .mov, .tmp1x, .memsi(.src0d, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_, .cvttps2dq, .dst0x, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cvttps2dq, .dst0x, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ },
                        .{ .@"0:", .v_, .cvttps2dq, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .cvttps2dq, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixsfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfsi" } },
                        .{ .type = .u32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixsfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfsi" } },
                        .{ .type = .u32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_, .cvttss2si, .tmp1q, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp1q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .cvttss2si, .tmp1q, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp1q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixsfdi" } },
                        .{ .type = .i64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfdi" } },
                        .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixsfdi" } },
                        .{ .type = .i64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfdi" } },
                        .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixsfti" } },
                        .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp3q0, ._, ._ },
                        .{ ._, ._, .mov, .memsid(.dst0q, .@"4", .tmp0, 8), .tmp3q1, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixsfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } },
                        .{ .type = .u128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp3q0, ._, ._ },
                        .{ ._, ._, .mov, .memsid(.dst0q, .@"4", .tmp0, 8), .tmp3q1, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixsfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixsfti" } },
                        .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp3q0, ._, ._ },
                        .{ ._, ._, .mov, .memsid(.dst0q, .@"4", .tmp0, 8), .tmp3q1, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixsfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } },
                        .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp3q0, ._, ._ },
                        .{ ._, ._, .mov, .memsid(.dst0q, .@"4", .tmp0, 8), .tmp3q1, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixsfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, .v_ss, .mov, .tmp4x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, .v_ss, .mov, .tmp4x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixsfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, ._ss, .mov, .tmp4x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, ._ss, .mov, .tmp4x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .float = .qword }, .any, .any },
                    .dst_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_, .cvttsd2si, .dst0d, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .float = .qword }, .any, .any },
                    .dst_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cvttsd2si, .dst0d, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .float = .qword }, .any, .any },
                    .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f64, .kind = .{ .reg = .st7 } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .i16, .kind = .mem },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0q, ._, ._, ._ },
                        .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .dst0d, .memd(.tmp1b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp1b, 1), .dst0b, ._, ._ },
                        .{ ._, .fi_p, .st, .tmp2w, ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .movsx, .dst0d, .tmp2b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .float = .qword }, .any, .any },
                    .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f64, .kind = .{ .reg = .st7 } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .i16, .kind = .mem },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0q, ._, ._, ._ },
                        .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .dst0d, .memd(.tmp1b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp1b, 1), .dst0b, ._, ._ },
                        .{ ._, .fi_p, .st, .tmp2w, ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .dst0d, .tmp2b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .float = .qword }, .any, .any },
                    .dst_constraints = .{ .{ .signed_or_exclusive_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f64, .kind = .{ .reg = .st7 } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0q, ._, ._, ._ },
                        .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
                        .{ ._, .fi_p, .st, .dst0w, ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .float = .qword }, .any, .any },
                    .dst_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f64, .kind = .{ .reg = .st7 } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0q, ._, ._, ._ },
                        .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
                        .{ ._, .fi_p, .st, .dst0d, ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{ .{ .float = .qword }, .any, .any },
                    .dst_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_, .cvttsd2si, .dst0q, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse2, null, null },
                    .src_constraints = .{ .{ .float = .qword }, .any, .any },
                    .dst_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cvttsd2si, .dst0q, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .float = .qword }, .any, .any },
                    .dst_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f64, .kind = .{ .reg = .st7 } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0q, ._, ._, ._ },
                        .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
                        .{ ._, .fi_p, .st, .dst0q, ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{ .{ .float = .qword }, .any, .any },
                    .dst_constraints = .{ .{ .exact_unsigned_int = 64 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .@"0x1p63_mem" = .{} } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp3), ._, ._ },
                        .{ ._, .v_, .cvttsd2si, .tmp2q, .src0d, ._, ._ },
                        .{ ._, .v_sd, .sub, .tmp0x, .src0x, .lea(.tmp1q), ._ },
                        .{ ._, .v_, .cvttsd2si, .dst0q, .tmp0d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .tmp2q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"and", .dst0q, .tmp2q, ._, ._ },
                        .{ ._, ._, .@"or", .dst0q, .tmp1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse2, null, null },
                    .src_constraints = .{ .{ .float = .qword }, .any, .any },
                    .dst_constraints = .{ .{ .exact_unsigned_int = 64 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .@"0x1p63_mem" = .{} } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                        .{ ._, ._, .cvttsd2si, .tmp1q, .src0d, ._, ._ },
                        .{ ._, ._sd, .sub, .src0x, .lea(.tmp0q), ._, ._ },
                        .{ ._, ._, .cvttsd2si, .dst0q, .src0d, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"and", .dst0q, .tmp1q, ._, ._ },
                        .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .x87, null, null },
                    .src_constraints = .{ .{ .float = .qword }, .any, .any },
                    .dst_constraints = .{ .{ .exact_unsigned_int = 64 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f64, .kind = .{ .reg = .st7 } },
                        .{ .type = .f64, .kind = .{ .reg = .st6 } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .f32, .kind = .{ .@"0x1p63_mem" = .{} } },
                        .{ .type = .i64, .kind = .mem },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0q, ._, ._, ._ },
                        .{ ._, .f_, .ld, .tmp0t, ._, ._, ._ },
                        .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .dst0d, .memd(.tmp2b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_11_00), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp2b, 1), .dst0b, ._, ._ },
                        .{ ._, ._, .lea, .dst0q, .mem(.tmp3), ._, ._ },
                        .{ ._, .fi_p, .st, .tmp4q, ._, ._, ._ },
                        .{ ._, .f_, .sub, .lea(.dst0d), ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp4q, ._, ._ },
                        .{ ._, .fi_p, .st, .tmp4q, ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0q, .tmp5q, ._, ._ },
                        .{ ._, ._r, .sa, .dst0q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"and", .dst0q, .tmp4q, ._, ._ },
                        .{ ._, ._, .@"or", .dst0q, .tmp5q, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .float = .qword }, .any, .any },
                    .dst_constraints = .{ .{ .signed_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixdfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .float = .qword }, .any, .any },
                    .dst_constraints = .{ .{ .signed_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixdfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .float = .qword }, .any, .any },
                    .dst_constraints = .{ .{ .unsigned_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .float = .qword }, .any, .any },
                    .dst_constraints = .{ .{ .unsigned_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .float = .qword }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixdfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .float = .qword }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .word, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .dword, .to = .byte } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_, .cvttpd2dq, .dst0x, .src0x, ._, ._ },
                        .{ ._, .vp_b, .shuf, .dst0x, .dst0x, .lea(.tmp0x), ._ },
                    } },
                }, .{
                    .required_features = .{ .ssse3, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .word, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .dword, .to = .byte } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._, .cvttpd2dq, .dst0x, .src0x, ._, ._ },
                        .{ ._, .p_b, .shuf, .dst0x, .lea(.tmp0x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .dword, .to = .byte } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_, .cvttpd2dq, .dst0x, .src0y, ._, ._ },
                        .{ ._, .vp_b, .shuf, .dst0x, .dst0x, .lea(.tmp0x), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .dword, .to = .byte } } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_size), ._, ._ },
                        .{ .@"0:", .v_, .cvttpd2dq, .tmp3x, .memsi(.src0y, .@"8", .tmp0), ._, ._ },
                        .{ ._, .vp_b, .shuf, .tmp3x, .tmp3x, .tmp2x, ._ },
                        .{ ._, .v_d, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .dword, .to = .byte } } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .cvttpd2dq, .tmp3x, .memsi(.src0x, .@"8", .tmp0), ._, ._ },
                        .{ ._, .p_b, .shuf, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .ssse3, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .dword, .to = .byte } } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .cvttpd2dq, .tmp3x, .memsi(.src0x, .@"8", .tmp0), ._, ._ },
                        .{ ._, .p_b, .shuf, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, ._d, .mov, .tmp4d, .tmp3x, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp4w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .cvttsd2si, .tmp1d, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp1b, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .cvttsd2si, .tmp1d, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp1b, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .reg = .st7 } },
                        .{ .type = .i16, .kind = .mem },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                        .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
                        .{ .@"0:", .f_, .ld, .memsi(.src0q, .@"8", .tmp0), ._, ._, ._ },
                        .{ ._, .fi_p, .st, .tmp4w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp2d, .tmp4b, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp2b, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .reg = .st7 } },
                        .{ .type = .i16, .kind = .mem },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                        .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
                        .{ .@"0:", .f_, .ld, .memsi(.src0q, .@"8", .tmp0), ._, ._, ._ },
                        .{ ._, .fi_p, .st, .tmp4w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp2d, .tmp4b, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp2b, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixdfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixdfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixdfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._sd, .mov, .tmp1x, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixsfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._sd, .mov, .tmp1x, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixdfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._ps, .movl, .tmp1x, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixsfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._ps, .movl, .tmp1x, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_, .cvttpd2dq, .dst0x, .src0x, ._, ._ },
                        .{ ._, .vp_w, .ackssd, .dst0x, .dst0x, .dst0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cvttpd2dq, .dst0x, .src0x, ._, ._ },
                        .{ ._, .p_w, .ackssd, .dst0x, .dst0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_, .cvttpd2dq, .dst0x, .src0y, ._, ._ },
                        .{ ._, .vp_w, .ackssd, .dst0x, .dst0x, .dst0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .dword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_, .cvttpd2dq, .dst0x, .src0x, ._, ._ },
                        .{ ._, .vp_w, .ackusd, .dst0x, .dst0x, .dst0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .dword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cvttpd2dq, .dst0x, .src0x, ._, ._ },
                        .{ ._, .p_w, .ackusd, .dst0x, .dst0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_, .cvttpd2dq, .dst0x, .src0y, ._, ._ },
                        .{ ._, .vp_w, .ackusd, .dst0x, .dst0x, .dst0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ },
                        .{ .@"0:", .v_, .cvttpd2dq, .tmp1x, .memsi(.src0y, .@"4", .tmp0), ._, ._ },
                        .{ ._, .vp_w, .ackssd, .tmp1x, .tmp1x, .tmp1x, ._ },
                        .{ ._, .v_q, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .cvttpd2dq, .tmp1x, .memsi(.src0x, .@"4", .tmp0), ._, ._ },
                        .{ ._, .p_w, .ackssd, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._d, .mov, .memi(.dst0d, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ },
                        .{ .@"0:", .v_, .cvttpd2dq, .tmp1x, .memsi(.src0y, .@"4", .tmp0), ._, ._ },
                        .{ ._, .vp_w, .ackusd, .tmp1x, .tmp1x, .tmp1x, ._ },
                        .{ ._, .v_q, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .cvttpd2dq, .tmp1x, .memsi(.src0x, .@"4", .tmp0), ._, ._ },
                        .{ ._, .p_w, .ackusd, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._d, .mov, .memi(.dst0d, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .cvttsd2si, .tmp1d, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .f64, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp0d, .memd(.tmp1b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp0b, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memsi(.src0q, .@"4", .tmp0), ._, ._, ._ },
                        .{ ._, .fi_p, .st, .memi(.dst0w, .tmp0), ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .reg = .st7 } },
                        .{ .type = .i32, .kind = .mem },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
                        .{ .@"0:", .f_, .ld, .memsi(.src0q, .@"4", .tmp0), ._, ._, ._ },
                        .{ ._, .fi_p, .st, .tmp4d, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp4d, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp2w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixdfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixdfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._sd, .mov, .tmp1x, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixdfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._ps, .movl, .tmp1x, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_, .cvttpd2dq, .dst0x, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cvttpd2dq, .dst0x, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_, .cvttpd2dq, .dst0x, .src0y, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ .@"0:", .v_, .cvttpd2dq, .tmp1x, .memsi(.src0y, .@"2", .tmp0), ._, ._ },
                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .cvttpd2dq, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._q, .mov, .memi(.dst0q, .tmp0), .tmp1q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .f64, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp0d, .memd(.tmp1b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp0b, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memsi(.src0q, .@"2", .tmp0), ._, ._, ._ },
                        .{ ._, .fi_p, .st, .memi(.dst0d, .tmp0), ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .reg = .st7 } },
                        .{ .type = .i64, .kind = .mem },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
                        .{ .@"0:", .f_, .ld, .memsi(.src0q, .@"2", .tmp0), ._, ._, ._ },
                        .{ ._, .fi_p, .st, .tmp4q, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp4d, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp2d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixdfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memsi(.src0q, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfsi" } },
                        .{ .type = .u32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memsi(.src0q, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixdfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._sd, .mov, .tmp1x, .memsi(.src0q, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfsi" } },
                        .{ .type = .u32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._sd, .mov, .tmp1x, .memsi(.src0q, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixdfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._ps, .movl, .tmp1x, .memsi(.src0q, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfsi" } },
                        .{ .type = .u32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._ps, .movl, .tmp1x, .memsi(.src0q, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_, .cvttsd2si, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp1q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse2, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .cvttsd2si, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp1q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .f64, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp0d, .memd(.tmp1b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp0b, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memi(.src0q, .tmp0), ._, ._, ._ },
                        .{ ._, .fi_p, .st, .memi(.dst0q, .tmp0), ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixdfdi" } },
                        .{ .type = .i64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfdi" } },
                        .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixdfdi" } },
                        .{ .type = .i64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfdi" } },
                        .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixdfdi" } },
                        .{ .type = .i64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._ps, .movl, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfdi" } },
                        .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._ps, .movl, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixdfti" } },
                        .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3q0, ._, ._ },
                        .{ ._, ._, .mov, .memsid(.dst0q, .@"2", .tmp0, 8), .tmp3q1, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixdfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfti" } },
                        .{ .type = .u128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3q0, ._, ._ },
                        .{ ._, ._, .mov, .memsid(.dst0q, .@"2", .tmp0, 8), .tmp3q1, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixdfti" } },
                        .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3q0, ._, ._ },
                        .{ ._, ._, .mov, .memsid(.dst0q, .@"2", .tmp0, 8), .tmp3q1, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixdfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfti" } },
                        .{ .type = .u128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3q0, ._, ._ },
                        .{ ._, ._, .mov, .memsid(.dst0q, .@"2", .tmp0, 8), .tmp3q1, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixdfti" } },
                        .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._ps, .movl, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3q0, ._, ._ },
                        .{ ._, ._, .mov, .memsid(.dst0q, .@"2", .tmp0, 8), .tmp3q1, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixdfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._ps, .movl, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfti" } },
                        .{ .type = .u128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._ps, .movl, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3q0, ._, ._ },
                        .{ ._, ._, .mov, .memsid(.dst0q, .@"2", .tmp0, 8), .tmp3q1, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._ps, .movl, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixdfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, .v_sd, .mov, .tmp4x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, .v_sd, .mov, .tmp4x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse2, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixdfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, ._sd, .mov, .tmp4x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse2, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, ._sd, .mov, .tmp4x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixdfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ .@"0:", ._ps, .xor, .tmp4x, .tmp4x, ._, ._ },
                        .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, ._ps, .movl, .tmp4x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ .@"0:", ._ps, .xor, .tmp4x, .tmp4x, ._, ._ },
                        .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, ._ps, .movl, .tmp4x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse3, .x87, null, null },
                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                    .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_x87, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .i16, .kind = .mem },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .fi_p, .stt, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .movsx, .dst0d, .tmp1b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                    .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_x87, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .i16, .kind = .mem },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .dst0d, .memd(.tmp1b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp1b, 1), .dst0b, ._, ._ },
                        .{ ._, .fi_p, .st, .tmp2w, ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .movsx, .dst0d, .tmp2b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse3, .x87, null, null },
                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                    .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_x87, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .i16, .kind = .mem },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .fi_p, .stt, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .dst0d, .tmp1b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                    .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_x87, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .i16, .kind = .mem },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .dst0d, .memd(.tmp1b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp1b, 1), .dst0b, ._, ._ },
                        .{ ._, .fi_p, .st, .tmp2w, ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .dst0d, .tmp2b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse3, .x87, .slow_incdec, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .i16, .kind = .mem },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .lea(.tmp0t), ._, ._, ._ },
                        .{ ._, .fi_p, .stt, .tmp3w, ._, ._, ._ },
                        .{ ._, ._, .movsx, .tmp4d, .tmp3b, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp4b, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse3, .x87, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .i16, .kind = .mem },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .lea(.tmp0t), ._, ._, ._ },
                        .{ ._, .fi_p, .stt, .tmp3w, ._, ._, ._ },
                        .{ ._, ._, .movsx, .tmp4d, .tmp3b, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp4b, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .i16, .kind = .mem },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                        .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp3d, .memd(.tmp2b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_11_00), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp2b, 1), .tmp3b, ._, ._ },
                        .{ .@"0:", .f_, .ld, .lea(.tmp0t), ._, ._, ._ },
                        .{ ._, .fi_p, .st, .tmp5w, ._, ._, ._ },
                        .{ ._, ._, .movsx, .tmp3d, .tmp5b, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp3b, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .i16, .kind = .mem },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                        .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp3d, .memd(.tmp2b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_11_00), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp2b, 1), .tmp3b, ._, ._ },
                        .{ .@"0:", .f_, .ld, .lea(.tmp0t), ._, ._, ._ },
                        .{ ._, .fi_p, .st, .tmp5w, ._, ._, ._ },
                        .{ ._, ._, .movsx, .tmp3d, .tmp5b, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp3b, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse3, .x87, .slow_incdec, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .i16, .kind = .mem },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .lea(.tmp0t), ._, ._, ._ },
                        .{ ._, .fi_p, .stt, .tmp3w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp4d, .tmp3b, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp4b, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse3, .x87, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .i16, .kind = .mem },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .lea(.tmp0t), ._, ._, ._ },
                        .{ ._, .fi_p, .stt, .tmp3w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp4d, .tmp3b, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp4b, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .i16, .kind = .mem },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                        .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp3d, .memd(.tmp2b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_11_00), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp2b, 1), .tmp3b, ._, ._ },
                        .{ .@"0:", .f_, .ld, .lea(.tmp0t), ._, ._, ._ },
                        .{ ._, .fi_p, .st, .tmp5w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp3d, .tmp5b, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp3b, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .i16, .kind = .mem },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                        .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp3d, .memd(.tmp2b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_11_00), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp2b, 1), .tmp3b, ._, ._ },
                        .{ .@"0:", .f_, .ld, .lea(.tmp0t), ._, ._, ._ },
                        .{ ._, .fi_p, .st, .tmp5w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp3d, .tmp5b, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp3b, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse3, .x87, null, null },
                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                    .dst_constraints = .{ .{ .signed_or_exclusive_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_x87, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .fi_p, .stt, .dst0w, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                    .dst_constraints = .{ .{ .signed_or_exclusive_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_x87, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
                        .{ ._, .fi_p, .st, .dst0w, ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse3, .x87, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memsi(.src0t, .@"8", .tmp0), ._, ._, ._ },
                        .{ ._, .fi_p, .stt, .memi(.dst0w, .tmp0), ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp0d, .memd(.tmp1b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp0b, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memsi(.src0t, .@"8", .tmp0), ._, ._, ._ },
                        .{ ._, .fi_p, .st, .memi(.dst0w, .tmp0), ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse3, .x87, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .i32, .kind = .mem },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memsi(.src0t, .@"8", .tmp0), ._, ._, ._ },
                        .{ ._, .fi_p, .stt, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .i32, .kind = .mem },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
                        .{ .@"0:", .f_, .ld, .memsi(.src0t, .@"8", .tmp0), ._, ._, ._ },
                        .{ ._, .fi_p, .st, .tmp4d, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp4d, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp2w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse3, .x87, null, null },
                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                    .dst_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_x87, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .fi_p, .stt, .dst0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                    .dst_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_x87, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
                        .{ ._, .fi_p, .st, .dst0d, ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse3, .x87, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memsi(.src0t, .@"4", .tmp0), ._, ._, ._ },
                        .{ ._, .fi_p, .stt, .memi(.dst0d, .tmp0), ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp0d, .memd(.tmp1b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp0b, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memsi(.src0t, .@"4", .tmp0), ._, ._, ._ },
                        .{ ._, .fi_p, .st, .memi(.dst0d, .tmp0), ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse3, .x87, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .i64, .kind = .mem },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memsi(.src0t, .@"4", .tmp0), ._, ._, ._ },
                        .{ ._, .fi_p, .stt, .tmp2q, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .i64, .kind = .mem },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
                        .{ .@"0:", .f_, .ld, .memsi(.src0t, .@"4", .tmp0), ._, ._, ._ },
                        .{ ._, .fi_p, .st, .tmp4q, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp4d, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp2d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse3, .x87, null, null },
                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                    .dst_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_x87, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .fi_p, .stt, .dst0q, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                    .dst_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_x87, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
                        .{ ._, .fi_p, .st, .dst0q, ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_features = .{ .@"64bit", .sse3, .x87, null },
                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                    .dst_constraints = .{ .{ .exact_unsigned_int = 64 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_x87, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .@"0x1p63_mem" = .{} } },
                        .{ .type = .f64, .kind = .{ .reg = .st6 } },
                        .{ .type = .f64, .kind = .{ .reg = .st7 } },
                        .{ .type = .i64, .kind = .mem },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .f_, .ld, .tmp3t, ._, ._, ._ },
                        .{ ._, .fi_p, .stt, .tmp4q, ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0q, .tmp4q, ._, ._ },
                        .{ ._, .f_, .sub, .lea(.tmp0d), ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ },
                        .{ ._, .fi_p, .stt, .tmp4q, ._, ._, ._ },
                        .{ ._, ._r, .sa, .dst0q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"and", .dst0q, .tmp4q, ._, ._ },
                        .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_features = .{ .@"64bit", .x87, null, null },
                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                    .dst_constraints = .{ .{ .exact_unsigned_int = 64 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_x87, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .f32, .kind = .{ .@"0x1p63_mem" = .{} } },
                        .{ .type = .i64, .kind = .mem },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .f_, .ld, .tmp0t, ._, ._, ._ },
                        .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .dst0d, .memd(.tmp2b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_11_00), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp2b, 1), .dst0b, ._, ._ },
                        .{ ._, ._, .lea, .dst0q, .mem(.tmp3), ._, ._ },
                        .{ ._, .fi_p, .st, .tmp4q, ._, ._, ._ },
                        .{ ._, .f_, .sub, .lea(.dst0d), ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp4q, ._, ._ },
                        .{ ._, .fi_p, .st, .tmp4q, ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0q, .tmp5q, ._, ._ },
                        .{ ._, ._r, .sa, .dst0q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"and", .dst0q, .tmp4q, ._, ._ },
                        .{ ._, ._, .@"or", .dst0q, .tmp5q, ._, ._ },
                    } },
                }, .{
                    .required_abi = .msvc,
                    .required_features = .{ .@"64bit", .x87, null, null },
                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                    .dst_constraints = .{ .{ .exact_unsigned_int = 64 }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_x87, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .f32, .kind = .{ .@"0x1p63_mem" = .{} } },
                        .{ .type = .i64, .kind = .mem },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
                        .{ ._, .f_, .ld, .tmp0t, ._, ._, ._ },
                        .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .dst0d, .memd(.tmp2b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_11_11), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp2b, 1), .dst0b, ._, ._ },
                        .{ ._, ._, .lea, .dst0q, .mem(.tmp3), ._, ._ },
                        .{ ._, .fi_p, .st, .tmp4q, ._, ._, ._ },
                        .{ ._, .f_, .sub, .lea(.dst0d), ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp5q, .tmp4q, ._, ._ },
                        .{ ._, .fi_p, .st, .tmp4q, ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
                        .{ ._, ._, .mov, .dst0q, .tmp5q, ._, ._ },
                        .{ ._, ._r, .sa, .dst0q, .ui(63), ._, ._ },
                        .{ ._, ._, .@"and", .dst0q, .tmp4q, ._, ._ },
                        .{ ._, ._, .@"or", .dst0q, .tmp5q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse3, .x87, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memsi(.src0t, .@"2", .tmp0), ._, ._, ._ },
                        .{ ._, .fi_p, .stt, .memi(.dst0q, .tmp0), ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp0d, .memd(.tmp1b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp0b, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .f_, .ld, .memsi(.src0t, .@"2", .tmp0), ._, ._, ._ },
                        .{ ._, .fi_p, .st, .memi(.dst0q, .tmp0), ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfdi" } },
                        .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp2x, .tmp1x, ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfdi" } },
                        .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfdi" } },
                        .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._ps, .mova, .tmp2x, .tmp1x, ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp4q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfdi" } },
                        .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                    .dst_constraints = .{ .{ .signed_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixxfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, .v_dqa, .mov, .tmp0x, .src0x, ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp1x, .tmp0x, ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                    .dst_constraints = .{ .{ .unsigned_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, .v_dqa, .mov, .tmp0x, .src0x, ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp1x, .tmp0x, ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                    .dst_constraints = .{ .{ .signed_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixxfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._dqa, .mov, .tmp0x, .src0x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp1x, .tmp0x, ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                    .dst_constraints = .{ .{ .unsigned_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._dqa, .mov, .tmp0x, .src0x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp1x, .tmp0x, ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                    .dst_constraints = .{ .{ .signed_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixxfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._ps, .mova, .tmp0x, .src0x, ._, ._ },
                        .{ ._, ._ps, .mova, .tmp1x, .tmp0x, ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                    .dst_constraints = .{ .{ .unsigned_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._ps, .mova, .tmp0x, .src0x, ._, ._ },
                        .{ ._, ._ps, .mova, .tmp1x, .tmp0x, ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                    .dst_constraints = .{ .{ .signed_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixxfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                    .dst_constraints = .{ .{ .unsigned_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixxfti" } },
                        .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp2x, .tmp1x, ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp4q0, ._, ._ },
                        .{ ._, ._, .mov, .memid(.dst0q, .tmp0, 8), .tmp4q1, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfti" } },
                        .{ .type = .u128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp2x, .tmp1x, ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp4q0, ._, ._ },
                        .{ ._, ._, .mov, .memid(.dst0q, .tmp0, 8), .tmp4q1, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixxfti" } },
                        .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp4q0, ._, ._ },
                        .{ ._, ._, .mov, .memid(.dst0q, .tmp0, 8), .tmp4q1, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfti" } },
                        .{ .type = .u128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp4q0, ._, ._ },
                        .{ ._, ._, .mov, .memid(.dst0q, .tmp0, 8), .tmp4q1, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixxfti" } },
                        .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._ps, .mova, .tmp2x, .tmp1x, ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp4q0, ._, ._ },
                        .{ ._, ._, .mov, .memid(.dst0q, .tmp0, 8), .tmp4q1, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfti" } },
                        .{ .type = .u128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._ps, .mova, .tmp2x, .tmp1x, ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp4q0, ._, ._ },
                        .{ ._, ._, .mov, .memid(.dst0q, .tmp0, 8), .tmp4q1, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixxfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp2x, .src0x, ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp2x, .src0x, ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixxfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .src0x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .src0x, ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixxfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, ._ps, .mova, .tmp2x, .src0x, ._, ._ },
                        .{ ._, ._ps, .mova, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, ._ps, .mova, .tmp2x, .src0x, ._, ._ },
                        .{ ._, ._ps, .mova, .tmp3x, .tmp2x, ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixxfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixxfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp4x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp5x, .tmp4x, ._, ._ },
                        .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp4x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp5x, .tmp4x, ._, ._ },
                        .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixxfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp4x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp5x, .tmp4x, ._, ._ },
                        .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp4x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp5x, .tmp4x, ._, ._ },
                        .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixxfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp4x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, ._ps, .mova, .tmp5x, .tmp4x, ._, ._ },
                        .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .size = 16, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp4x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, ._ps, .mova, .tmp5x, .tmp4x, ._, ._ },
                        .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixxfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp4p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp4p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp4b, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp4b, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp4b, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp4b, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp4b, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp2x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp4b, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp4b, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp4b, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ },
                        .{ ._, ._c, .de, .tmp1d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsi(.src0x, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memsi(.src0x, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memsi(.src0x, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .float = .xword }, .any, .any },
                    .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .float = .xword }, .any, .any },
                    .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfsi" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .float = .xword }, .any, .any },
                    .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .float = .xword }, .any, .any },
                    .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfsi" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsi(.src0x, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsi(.src0x, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memsi(.src0x, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memsi(.src0x, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memsi(.src0x, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfsi" } },
                        .{ .type = .u32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memsi(.src0x, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } },
                        .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfsi" } },
                        .{ .type = .u32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .float = .xword }, .any, .any },
                    .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfdi" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .float = .xword }, .any, .any },
                    .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfdi" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .float = .xword }, .any, .any },
                    .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfdi" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .float = .xword }, .any, .any },
                    .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfdi" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfdi" } },
                        .{ .type = .i64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfdi" } },
                        .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .@"64bit", .sse2, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfdi" } },
                        .{ .type = .i64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .@"64bit", .sse2, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfdi" } },
                        .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfdi" } },
                        .{ .type = .i64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfdi" } },
                        .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfdi" } },
                        .{ .type = .i64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfdi" } },
                        .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .float = .xword }, .any, .any },
                    .dst_constraints = .{ .{ .signed_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .float = .xword }, .any, .any },
                    .dst_constraints = .{ .{ .unsigned_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .float = .xword }, .any, .any },
                    .dst_constraints = .{ .{ .signed_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .float = .xword }, .any, .any },
                    .dst_constraints = .{ .{ .unsigned_int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfti" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfti" } },
                        .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q0, ._, ._ },
                        .{ ._, ._, .mov, .memid(.dst0q, .tmp0, 8), .tmp3q1, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfti" } },
                        .{ .type = .u128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q0, ._, ._ },
                        .{ ._, ._, .mov, .memid(.dst0q, .tmp0, 8), .tmp3q1, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfti" } },
                        .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q0, ._, ._ },
                        .{ ._, ._, .mov, .memid(.dst0q, .tmp0, 8), .tmp3q1, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfti" } },
                        .{ .type = .u128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q0, ._, ._ },
                        .{ ._, ._, .mov, .memid(.dst0q, .tmp0, 8), .tmp3q1, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfti" } },
                        .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q0, ._, ._ },
                        .{ ._, ._, .mov, .memid(.dst0q, .tmp0, 8), .tmp3q1, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfti" } },
                        .{ .type = .u128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q0, ._, ._ },
                        .{ ._, ._, .mov, .memid(.dst0q, .tmp0, 8), .tmp3q1, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfti" } },
                        .{ .type = .i128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfti" } },
                        .{ .type = .u128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfti" } },
                        .{ .type = .i128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfti" } },
                        .{ .type = .u128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfti" } },
                        .{ .type = .i128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfti" } },
                        .{ .type = .u128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .float = .xword }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .float = .xword }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .float = .xword }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .float = .xword }, .any, .any },
                    .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp4x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp4x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .@"64bit", .sse2, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp4x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .@"64bit", .sse2, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp4x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, ._ps, .mova, .tmp4x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, ._ps, .mova, .tmp4x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixtfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp4p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfei" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp4p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f} {f}", .{
                        @tagName(air_tag),
                        ty_op.ty.toType().fmt(pt),
                        cg.typeOf(ty_op.operand).fmt(pt),
                        ops[0].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{ty_op.operand}, &ops, cg);
            },
            .int_from_float_safe => unreachable,
            .int_from_float_optimized_safe => unreachable,
            .float_from_int => |air_tag| {
                const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                var res: [1]Temp = undefined;
                cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .byte }, .any, .any },
                    .dst_constraints = .{ .{ .float = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ },
                        .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ },
                        .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any },
                    .dst_constraints = .{ .{ .float = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ },
                        .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ },
                        .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .any, .any },
                    .dst_constraints = .{ .{ .float = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movsx, .tmp0d, .src0w, ._, ._ },
                        .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ },
                        .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any },
                    .dst_constraints = .{ .{ .float = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ },
                        .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ },
                        .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ },
                        .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .src0d, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .f16c, null, null },
                    .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .any, .any },
                    .dst_constraints = .{ .{ .float = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ },
                        .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0q, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .f16c, null, null },
                    .src_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ },
                        .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .src0q, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .f16c, null, null },
                    .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any },
                    .dst_constraints = .{ .{ .float = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u1, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ },
                        .{ ._, ._, .@"test", .src0q, .src0q, ._, ._ },
                        .{ ._, ._ns, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sh, .src0q, .ui(1), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._, .@"or", .src0q, .tmp0q, ._, ._ },
                        .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .src0q, ._ },
                        .{ ._, .v_ss, .add, .dst0x, .dst0x, .dst0d, ._ },
                        .{ ._, ._mp, .j, .@"0f", ._, ._, ._ },
                        .{ .@"1:", .v_ss, .cvtsi2, .dst0x, .dst0x, .src0q, ._ },
                        .{ .@"0:", .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .byte }, .any, .any },
                    .dst_constraints = .{ .{ .float = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movsx, .src0d, .src0b, ._, ._ },
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any },
                    .dst_constraints = .{ .{ .float = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .src0d, .src0b, ._, ._ },
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .any, .any },
                    .dst_constraints = .{ .{ .float = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movsx, .src0d, .src0w, ._, ._ },
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any },
                    .dst_constraints = .{ .{ .float = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .src0d, .src0w, ._, ._ },
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .dword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatdihf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatundihf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .xword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__floattihf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .xword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floattihf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntihf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntihf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .float = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floateihf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .float = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuneihf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .movsxb, .dst0x, .src0d, ._, ._ },
                        .{ ._, .v_ps, .cvtdq2, .dst0x, .dst0x, ._, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, .avx2, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .movsxb, .dst0y, .src0q, ._, ._ },
                        .{ ._, .v_ps, .cvtdq2, .dst0y, .dst0y, ._, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .movzxb, .dst0x, .src0d, ._, ._ },
                        .{ ._, .v_ps, .cvtdq2, .dst0x, .dst0x, ._, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, .avx2, null, null },
                    .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .movzxb, .dst0y, .src0q, ._, ._ },
                        .{ ._, .v_ps, .cvtdq2, .dst0y, .dst0y, ._, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, .avx2, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size_up_8), ._, ._ },
                        .{ .@"0:", .vp_d, .movsxb, .tmp1y, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, .v_ps, .cvtdq2, .tmp1y, .tmp1y, ._, ._ },
                        .{ ._, .v_, .cvtps2ph, .memsi(.dst0x, .@"2", .tmp0), .tmp1y, .rm(.{}), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size_up_4), ._, ._ },
                        .{ .@"0:", .vp_d, .movsxb, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, .v_ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .v_, .cvtps2ph, .memsi(.dst0q, .@"2", .tmp0), .tmp1x, .rm(.{}), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, .avx2, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size_up_8), ._, ._ },
                        .{ .@"0:", .vp_d, .movzxb, .tmp1y, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, .v_ps, .cvtdq2, .tmp1y, .tmp1y, ._, ._ },
                        .{ ._, .v_, .cvtps2ph, .memsi(.dst0x, .@"2", .tmp0), .tmp1y, .rm(.{}), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size_up_4), ._, ._ },
                        .{ .@"0:", .vp_d, .movzxb, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, .v_ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .v_, .cvtps2ph, .memsi(.dst0q, .@"2", .tmp0), .tmp1x, .rm(.{}), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .vp_w, .extr, .memsi(.dst0w, .@"2", .tmp0), .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .vp_w, .extr, .memsi(.dst0w, .@"2", .tmp0), .tmp3x, .ui(0), ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .memsi(.dst0w, .@"2", .tmp0), .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .memsi(.dst0w, .@"2", .tmp0), .tmp3x, .ui(0), ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .mov, .memsi(.dst0w, .@"2", .tmp0), .tmp1w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .mov, .memsi(.dst0w, .@"2", .tmp0), .tmp1w, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f32, .kind = .mem },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0w, .@"2", .tmp0), .tmp1w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f32, .kind = .mem },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0w, .@"2", .tmp0), .tmp1w, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .vp_w, .extr, .memsi(.dst0w, .@"2", .tmp0), .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .vp_w, .extr, .memsi(.dst0w, .@"2", .tmp0), .tmp3x, .ui(0), ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .memsi(.dst0w, .@"2", .tmp0), .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .memsi(.dst0w, .@"2", .tmp0), .tmp3x, .ui(0), ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .mov, .memsi(.dst0w, .@"2", .tmp0), .tmp1w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .mov, .memsi(.dst0w, .@"2", .tmp0), .tmp1w, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f32, .kind = .mem },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0w, .@"2", .tmp0), .tmp1w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f32, .kind = .mem },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ },
                        .{ ._, ._, .mov, .memsi(.dst0w, .@"2", .tmp0), .tmp1w, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .movsxw, .dst0x, .src0q, ._, ._ },
                        .{ ._, .v_ps, .cvtdq2, .dst0x, .dst0x, ._, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, .avx2, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .movsxw, .dst0y, .src0x, ._, ._ },
                        .{ ._, .v_ps, .cvtdq2, .dst0y, .dst0y, ._, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .movzxw, .dst0x, .src0q, ._, ._ },
                        .{ ._, .v_ps, .cvtdq2, .dst0x, .dst0x, ._, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, .avx2, null, null },
                    .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .movzxw, .dst0y, .src0x, ._, ._ },
                        .{ ._, .v_ps, .cvtdq2, .dst0y, .dst0y, ._, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, .avx2, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size_up_16), ._, ._ },
                        .{ .@"0:", .vp_d, .movsxw, .tmp1y, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, .v_ps, .cvtdq2, .tmp1y, .tmp1y, ._, ._ },
                        .{ ._, .v_, .cvtps2ph, .memi(.dst0x, .tmp0), .tmp1y, .rm(.{}), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size_up_8), ._, ._ },
                        .{ .@"0:", .vp_d, .movsxw, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, .v_ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .v_, .cvtps2ph, .memi(.dst0q, .tmp0), .tmp1x, .rm(.{}), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, .avx2, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size_up_16), ._, ._ },
                        .{ .@"0:", .vp_d, .movzxw, .tmp1y, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, .v_ps, .cvtdq2, .tmp1y, .tmp1y, ._, ._ },
                        .{ ._, .v_, .cvtps2ph, .memi(.dst0x, .tmp0), .tmp1y, .rm(.{}), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size_up_8), ._, ._ },
                        .{ .@"0:", .vp_d, .movzxw, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, .v_ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .v_, .cvtps2ph, .memi(.dst0q, .tmp0), .tmp1x, .rm(.{}), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f32, .kind = .mem },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f32, .kind = .mem },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtdq2, .dst0x, .src0x, ._, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, .avx2, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtdq2, .dst0y, .src0y, ._, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, .avx2, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_unaligned_size_up_16), ._, ._ },
                        .{ .@"0:", .v_ps, .cvtdq2, .tmp1y, .memsi(.src0y, .@"2", .tmp0), ._, ._ },
                        .{ ._, .v_, .cvtps2ph, .memi(.dst0x, .tmp0), .tmp1y, .rm(.{}), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .f16c, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size_up_8), ._, ._ },
                        .{ .@"0:", .v_ps, .cvtdq2, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ },
                        .{ ._, .v_, .cvtps2ph, .memi(.dst0q, .tmp0), .tmp1x, .rm(.{}), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsi(.src0d, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsi(.src0d, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsi(.src0d, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f32, .kind = .mem },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsi(.src0d, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsi(.src0d, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsi(.src0d, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsi(.src0d, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f32, .kind = .mem },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memsi(.src0d, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .f16c, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_ps, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
                        .{ ._, .v_ss, .cvtsi2, .tmp1x, .tmp1x, .memsi(.src0q, .@"4", .tmp0), ._ },
                        .{ ._, .v_, .cvtps2ph, .tmp1q, .tmp1x, .rm(.{}), ._ },
                        .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatdihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse4_1, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatdihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse2, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatdihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatdihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f32, .kind = .mem },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatundihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse4_1, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatundihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse2, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatundihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatundihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f32, .kind = .mem },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floattihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"8", .tmp0, 8), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floattihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floattihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"8", .tmp0, 8), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floattihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floattihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"8", .tmp0, 8), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .tmp1d0, .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w0, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floattihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floattihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f32, .kind = .mem },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"8", .tmp0, 8), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .mem(.tmp4d), .tmp3x, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d0, .mem(.tmp4d), ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w0, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floattihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f32, .kind = .mem },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .mem(.tmp4d), .tmp3x, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .mem(.tmp4d), ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"8", .tmp0, 8), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"8", .tmp0, 8), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"8", .tmp0, 8), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .tmp1d0, .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w0, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f32, .kind = .mem },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"8", .tmp0, 8), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .mem(.tmp4d), .tmp3x, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d0, .mem(.tmp4d), ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w0, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f32, .kind = .mem },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .mem(.tmp4d), .tmp3x, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .mem(.tmp4d), ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floateihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp1), .tmp5x, .ui(0), ._ },
                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse4_1, null, null },
                    .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floateihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .memi(.dst0w, .tmp1), .tmp5x, .ui(0), ._ },
                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse2, null, null },
                    .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floateihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .tmp2d, .tmp5x, .ui(0), ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp1), .tmp2w, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floateihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f32, .kind = .mem },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp6d, .tmp5d, ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp6d, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp1), .tmp2w, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuneihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp1), .tmp5x, .ui(0), ._ },
                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse4_1, null, null },
                    .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuneihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .memi(.dst0w, .tmp1), .tmp5x, .ui(0), ._ },
                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse2, null, null },
                    .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuneihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .tmp2d, .tmp5x, .ui(0), ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp1), .tmp2w, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuneihf" } },
                        .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f32, .kind = .mem },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp6d, .tmp5d, ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp6d, ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp1), .tmp2w, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .byte }, .any, .any },
                    .dst_constraints = .{ .{ .float = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ },
                        .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ },
                        .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .byte }, .any, .any },
                    .dst_constraints = .{ .{ .float = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ },
                        .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ },
                        .{ ._, ._ss, .cvtsi2, .dst0x, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any },
                    .dst_constraints = .{ .{ .float = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ },
                        .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ },
                        .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any },
                    .dst_constraints = .{ .{ .float = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ },
                        .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ },
                        .{ ._, ._ss, .cvtsi2, .dst0x, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .any, .any },
                    .dst_constraints = .{ .{ .float = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movsx, .tmp0d, .src0w, ._, ._ },
                        .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ },
                        .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .any, .any },
                    .dst_constraints = .{ .{ .float = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movsx, .tmp0d, .src0w, ._, ._ },
                        .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ },
                        .{ ._, ._ss, .cvtsi2, .dst0x, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any },
                    .dst_constraints = .{ .{ .float = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ },
                        .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ },
                        .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any },
                    .dst_constraints = .{ .{ .float = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ },
                        .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ },
                        .{ ._, ._ss, .cvtsi2, .dst0x, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ },
                        .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .src0d, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ },
                        .{ ._, ._ss, .cvtsi2, .dst0x, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .any, .any },
                    .dst_constraints = .{ .{ .float = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ },
                        .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0q, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .any, .any },
                    .dst_constraints = .{ .{ .float = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ },
                        .{ ._, ._ss, .cvtsi2, .dst0x, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ },
                        .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .src0q, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ },
                        .{ ._, ._ss, .cvtsi2, .dst0x, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any },
                    .dst_constraints = .{ .{ .float = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u1, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ },
                        .{ ._, ._, .@"test", .src0q, .src0q, ._, ._ },
                        .{ ._, ._ns, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sh, .src0q, .ui(1), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._, .@"or", .src0q, .tmp0q, ._, ._ },
                        .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .src0q, ._ },
                        .{ ._, .v_ss, .add, .dst0x, .dst0x, .dst0d, ._ },
                        .{ ._, ._mp, .j, .@"0f", ._, ._, ._ },
                        .{ .@"1:", .v_ss, .cvtsi2, .dst0x, .dst0x, .src0q, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any },
                    .dst_constraints = .{ .{ .float = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u1, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ },
                        .{ ._, ._, .@"test", .src0q, .src0q, ._, ._ },
                        .{ ._, ._ns, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sh, .src0q, .ui(1), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._, .@"or", .src0q, .tmp0q, ._, ._ },
                        .{ ._, ._ss, .cvtsi2, .dst0x, .src0q, ._, ._ },
                        .{ ._, ._ss, .add, .dst0x, .dst0d, ._, ._ },
                        .{ ._, ._mp, .j, .@"0f", ._, ._, ._ },
                        .{ .@"1:", ._ss, .cvtsi2, .dst0x, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .xword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__floattisf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .xword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floattisf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntisf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntisf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .float = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floateisf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .float = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuneisf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .movsxb, .dst0x, .src0d, ._, ._ },
                        .{ ._, .v_ps, .cvtdq2, .dst0x, .dst0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_d, .movsxb, .dst0x, .src0d, ._, ._ },
                        .{ ._, ._ps, .cvtdq2, .dst0x, .dst0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .movsxb, .dst0y, .src0q, ._, ._ },
                        .{ ._, .v_ps, .cvtdq2, .dst0y, .dst0y, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .movzxb, .dst0x, .src0d, ._, ._ },
                        .{ ._, .v_ps, .cvtdq2, .dst0x, .dst0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_d, .movzxb, .dst0x, .src0d, ._, ._ },
                        .{ ._, ._ps, .cvtdq2, .dst0x, .dst0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .movzxb, .dst0y, .src0q, ._, ._ },
                        .{ ._, .v_ps, .cvtdq2, .dst0y, .dst0y, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size_up_8), ._, ._ },
                        .{ .@"0:", .vp_d, .movsxb, .tmp1y, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, .v_ps, .cvtdq2, .tmp1y, .tmp1y, ._, ._ },
                        .{ ._, .v_ps, .mova, .memsi(.dst0y, .@"4", .tmp0), .tmp1y, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size_up_4), ._, ._ },
                        .{ .@"0:", .vp_d, .movsxb, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, .v_ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .v_ps, .mova, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size_up_4), ._, ._ },
                        .{ .@"0:", .p_d, .movsxb, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._ps, .mova, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size_up_8), ._, ._ },
                        .{ .@"0:", .vp_d, .movzxb, .tmp1y, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, .v_ps, .cvtdq2, .tmp1y, .tmp1y, ._, ._ },
                        .{ ._, .v_ps, .mova, .memsi(.dst0y, .@"4", .tmp0), .tmp1y, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size_up_4), ._, ._ },
                        .{ .@"0:", .vp_d, .movzxb, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, .v_ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .v_ps, .mova, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size_up_4), ._, ._ },
                        .{ .@"0:", .p_d, .movzxb, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._ps, .mova, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsisf" } },
                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_ss, .mov, .memsi(.dst0d, .@"4", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsisf" } },
                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_ss, .mov, .memsi(.dst0d, .@"4", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsisf" } },
                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .memsi(.dst0d, .@"4", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsisf" } },
                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .memsi(.dst0d, .@"4", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsisf" } },
                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_ss, .mov, .memsi(.dst0d, .@"4", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsisf" } },
                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_ss, .mov, .memsi(.dst0d, .@"4", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsisf" } },
                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .memsi(.dst0d, .@"4", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsisf" } },
                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .memsi(.dst0d, .@"4", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .movsxw, .dst0x, .src0q, ._, ._ },
                        .{ ._, .v_ps, .cvtdq2, .dst0x, .dst0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_d, .movsxw, .dst0x, .src0q, ._, ._ },
                        .{ ._, ._ps, .cvtdq2, .dst0x, .dst0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .movsxw, .dst0y, .src0x, ._, ._ },
                        .{ ._, .v_ps, .cvtdq2, .dst0y, .dst0y, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .movzxw, .dst0x, .src0q, ._, ._ },
                        .{ ._, .v_ps, .cvtdq2, .dst0x, .dst0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_d, .movzxw, .dst0x, .src0q, ._, ._ },
                        .{ ._, ._ps, .cvtdq2, .dst0x, .dst0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .movzxw, .dst0y, .src0x, ._, ._ },
                        .{ ._, .v_ps, .cvtdq2, .dst0y, .dst0y, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size_up_16), ._, ._ },
                        .{ .@"0:", .vp_d, .movsxw, .tmp1y, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, .v_ps, .cvtdq2, .tmp1y, .tmp1y, ._, ._ },
                        .{ ._, .v_ps, .mova, .memsi(.dst0y, .@"2", .tmp0), .tmp1y, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size_up_8), ._, ._ },
                        .{ .@"0:", .vp_d, .movsxw, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, .v_ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .v_ps, .mova, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size_up_8), ._, ._ },
                        .{ .@"0:", .p_d, .movsxw, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._ps, .mova, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size_up_16), ._, ._ },
                        .{ .@"0:", .vp_d, .movzxw, .tmp1y, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, .v_ps, .cvtdq2, .tmp1y, .tmp1y, ._, ._ },
                        .{ ._, .v_ps, .mova, .memsi(.dst0y, .@"2", .tmp0), .tmp1y, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size_up_8), ._, ._ },
                        .{ .@"0:", .vp_d, .movzxw, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, .v_ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .v_ps, .mova, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size_up_8), ._, ._ },
                        .{ .@"0:", .p_d, .movzxw, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._ps, .mova, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsisf" } },
                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_ss, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsisf" } },
                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsisf" } },
                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_ss, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsisf" } },
                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtdq2, .dst0x, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._ps, .cvtdq2, .dst0x, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtdq2, .dst0y, .src0y, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size_up_32), ._, ._ },
                        .{ .@"0:", .v_ps, .cvtdq2, .tmp1y, .memi(.src0y, .tmp0), ._, ._ },
                        .{ ._, .v_ps, .mova, .memi(.dst0y, .tmp0), .tmp1y, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_unaligned_size_up_16), ._, ._ },
                        .{ .@"0:", .v_ps, .cvtdq2, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, .v_ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_unaligned_size_up_16), ._, ._ },
                        .{ .@"0:", ._ps, .cvtdq2, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ss, .cvtsi2, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsisf" } },
                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsisf" } },
                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsisf" } },
                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsisf" } },
                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_ps, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
                        .{ ._, .v_ss, .cvtsi2, .tmp1x, .tmp1x, .memsi(.src0q, .@"2", .tmp0), ._ },
                        .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._ss, .cvtsi2, .tmp1x, .memsi(.src0q, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatdisf" } },
                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsi(.src0q, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatdisf" } },
                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsi(.src0q, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatundisf" } },
                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsi(.src0q, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatundisf" } },
                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsi(.src0q, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floattisf" } },
                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"4", .tmp0, 8), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floattisf" } },
                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floattisf" } },
                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"4", .tmp0, 8), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floattisf" } },
                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntisf" } },
                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"4", .tmp0, 8), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntisf" } },
                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntisf" } },
                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"4", .tmp0, 8), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntisf" } },
                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floateisf" } },
                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp1), .tmp5x, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floateisf" } },
                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .memi(.dst0d, .tmp1), .tmp5x, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuneisf" } },
                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp1), .tmp5x, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuneisf" } },
                        .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .memi(.dst0d, .tmp1), .tmp5x, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .byte }, .any, .any },
                    .dst_constraints = .{ .{ .float = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ },
                        .{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ },
                        .{ ._, .v_sd, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .byte }, .any, .any },
                    .dst_constraints = .{ .{ .float = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ },
                        .{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ },
                        .{ ._, ._sd, .cvtsi2, .dst0x, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any },
                    .dst_constraints = .{ .{ .float = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ },
                        .{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ },
                        .{ ._, .v_sd, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any },
                    .dst_constraints = .{ .{ .float = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ },
                        .{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ },
                        .{ ._, ._sd, .cvtsi2, .dst0x, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .any, .any },
                    .dst_constraints = .{ .{ .float = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movsx, .tmp0d, .src0w, ._, ._ },
                        .{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ },
                        .{ ._, .v_sd, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .any, .any },
                    .dst_constraints = .{ .{ .float = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movsx, .tmp0d, .src0w, ._, ._ },
                        .{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ },
                        .{ ._, ._sd, .cvtsi2, .dst0x, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any },
                    .dst_constraints = .{ .{ .float = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ },
                        .{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ },
                        .{ ._, .v_sd, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any },
                    .dst_constraints = .{ .{ .float = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ },
                        .{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ },
                        .{ ._, ._sd, .cvtsi2, .dst0x, .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ },
                        .{ ._, .v_sd, .cvtsi2, .dst0x, .dst0x, .src0d, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ },
                        .{ ._, ._sd, .cvtsi2, .dst0x, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .any, .any },
                    .dst_constraints = .{ .{ .float = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ },
                        .{ ._, .v_sd, .cvtsi2, .dst0x, .dst0x, .tmp0q, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .any, .any },
                    .dst_constraints = .{ .{ .float = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ },
                        .{ ._, ._sd, .cvtsi2, .dst0x, .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .byte }, .any, .any },
                    .dst_constraints = .{ .{ .float = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .{ .type = .i16, .kind = .mem },
                        .{ .type = .f64, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1w, .tmp0w, ._, ._ },
                        .{ ._, .fi_, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any },
                    .dst_constraints = .{ .{ .float = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .{ .type = .i16, .kind = .mem },
                        .{ .type = .f64, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1w, .tmp0w, ._, ._ },
                        .{ ._, .fi_, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .signed_or_exclusive_int = .word }, .any, .any },
                    .dst_constraints = .{ .{ .float = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f64, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .fi_, .ld, .src0w, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .exact_unsigned_int = 16 }, .any, .any },
                    .dst_constraints = .{ .{ .float = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .{ .type = .i32, .kind = .mem },
                        .{ .type = .f64, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, .fi_, .ld, .tmp1d, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f64, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .fi_, .ld, .src0d, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .x87, null, null },
                    .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .any, .any },
                    .dst_constraints = .{ .{ .float = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .{ .type = .i64, .kind = .mem },
                        .{ .type = .f64, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, .fi_, .ld, .tmp1q, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ },
                        .{ ._, .v_sd, .cvtsi2, .dst0x, .dst0x, .src0q, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse2, null, null },
                    .src_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ },
                        .{ ._, ._sd, .cvtsi2, .dst0x, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any },
                    .dst_constraints = .{ .{ .float = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u32, .kind = .u32_0x1p52_hi_0x1p84_hi_0_0_mem },
                        .{ .type = .vector_2_f64, .kind = .f64_0x1p52_0x1p84_mem },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_q, .mov, .tmp0x, .src0q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ },
                        .{ ._, .vp_, .unpckldq, .tmp0x, .tmp0x, .lea(.tmp1x), ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp3), ._, ._ },
                        .{ ._, .v_pd, .sub, .tmp0x, .tmp0x, .lea(.tmp1x), ._ },
                        .{ ._, .v_pd, .unpckh, .dst0x, .tmp0x, .tmp0x, ._ },
                        .{ ._, .v_sd, .add, .dst0x, .dst0x, .tmp0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse2, null, null },
                    .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any },
                    .dst_constraints = .{ .{ .float = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u32, .kind = .u32_0x1p52_hi_0x1p84_hi_0_0_mem },
                        .{ .type = .vector_2_f64, .kind = .f64_0x1p52_0x1p84_mem },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._q, .mov, .tmp0x, .src0q, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ },
                        .{ ._, .p_, .unpckldq, .tmp0x, .lea(.tmp1x), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp3), ._, ._ },
                        .{ ._, ._pd, .sub, .tmp0x, .lea(.tmp1x), ._, ._ },
                        .{ ._, ._pd, .mova, .dst0x, .tmp0x, ._, ._ },
                        .{ ._, ._pd, .unpckh, .dst0x, .dst0x, ._, ._ },
                        .{ ._, ._sd, .add, .dst0x, .tmp0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f64, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .fi_, .ld, .src0q, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .x87, null, null },
                    .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any },
                    .dst_constraints = .{ .{ .float = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u1, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .@"test", .src0q, .src0q, ._, ._ },
                        .{ ._, ._ns, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._r, .sh, .src0q, .ui(1), ._, ._ },
                        .{ ._, ._, .@"and", .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._, .@"or", .src0q, .tmp0q, ._, ._ },
                        .{ ._, ._, .mov, .dst0q, .src0q, ._, ._ },
                        .{ ._, .fi_, .ld, .dst0q, ._, ._, ._ },
                        .{ ._, .f_, .add, .tmp1t, .tmp1t, ._, ._ },
                        .{ ._, ._mp, .j, .@"0f", ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .in, ._, ._, ._, ._ },
                        .{ .@"1:", ._, .mov, .dst0q, .src0q, ._, ._ },
                        .{ ._, .fi_, .ld, .dst0q, ._, ._, ._ },
                        .{ .@"0:", .f_p, .st, .dst0q, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .xword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__floattidf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .xword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floattidf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntidf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntidf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .float = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floateidf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .float = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuneidf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .word, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .movsxb, .dst0x, .src0d, ._, ._ },
                        .{ ._, .v_pd, .cvtdq2, .dst0x, .dst0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .word, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_d, .movsxb, .dst0x, .src0d, ._, ._ },
                        .{ ._, ._pd, .cvtdq2, .dst0x, .dst0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .movsxb, .dst0x, .src0d, ._, ._ },
                        .{ ._, .v_pd, .cvtdq2, .dst0y, .dst0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .word, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .movzxb, .dst0x, .src0d, ._, ._ },
                        .{ ._, .v_pd, .cvtdq2, .dst0x, .dst0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .word, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_d, .movzxb, .dst0x, .src0d, ._, ._ },
                        .{ ._, ._pd, .cvtdq2, .dst0x, .dst0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .movzxb, .dst0x, .src0d, ._, ._ },
                        .{ ._, .v_pd, .cvtdq2, .dst0y, .dst0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size_up_4), ._, ._ },
                        .{ .@"0:", .vp_d, .movsxb, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, .v_pd, .cvtdq2, .tmp1y, .tmp1x, ._, ._ },
                        .{ ._, .v_pd, .mova, .memsi(.dst0y, .@"8", .tmp0), .tmp1y, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size_up_2), ._, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                        .{ ._, .vp_d, .movsxb, .tmp1x, .tmp1d, ._, ._ },
                        .{ ._, .v_pd, .cvtdq2, .tmp1x, .tmp1q, ._, ._ },
                        .{ ._, .v_pd, .mova, .memsi(.dst0x, .@"8", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size_up_2), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                        .{ ._, .p_d, .movsxb, .tmp1x, .tmp1d, ._, ._ },
                        .{ ._, ._pd, .cvtdq2, .tmp1x, .tmp1q, ._, ._ },
                        .{ ._, ._pd, .mova, .memsi(.dst0x, .@"8", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size_up_4), ._, ._ },
                        .{ .@"0:", .vp_d, .movzxb, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, .v_pd, .cvtdq2, .tmp1y, .tmp1x, ._, ._ },
                        .{ ._, .v_pd, .mova, .memsi(.dst0y, .@"8", .tmp0), .tmp1y, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size_up_2), ._, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
                        .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                        .{ ._, .vp_d, .movzxb, .tmp1x, .tmp1d, ._, ._ },
                        .{ ._, .v_pd, .cvtdq2, .tmp1x, .tmp1q, ._, ._ },
                        .{ ._, .v_pd, .mova, .memsi(.dst0x, .@"8", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size_up_2), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                        .{ ._, .p_d, .movzxb, .tmp1x, .tmp1d, ._, ._ },
                        .{ ._, ._pd, .cvtdq2, .tmp1x, .tmp1q, ._, ._ },
                        .{ ._, ._pd, .mova, .memsi(.dst0x, .@"8", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_sd, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_sd, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._sd, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._sd, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ps, .movl, .memsi(.dst0q, .@"8", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ps, .movl, .memsi(.dst0q, .@"8", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_sd, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_sd, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._sd, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._sd, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ps, .movl, .memsi(.dst0q, .@"8", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ps, .movl, .memsi(.dst0q, .@"8", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .movsxw, .dst0x, .src0q, ._, ._ },
                        .{ ._, .v_pd, .cvtdq2, .dst0x, .dst0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_d, .movsxw, .dst0x, .src0q, ._, ._ },
                        .{ ._, ._pd, .cvtdq2, .dst0x, .dst0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .movsxw, .dst0x, .src0q, ._, ._ },
                        .{ ._, .v_pd, .cvtdq2, .dst0y, .dst0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .dword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .movzxw, .dst0x, .src0q, ._, ._ },
                        .{ ._, .v_pd, .cvtdq2, .dst0x, .dst0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .dword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_d, .movzxw, .dst0x, .src0q, ._, ._ },
                        .{ ._, ._pd, .cvtdq2, .dst0x, .dst0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .movzxw, .dst0x, .src0q, ._, ._ },
                        .{ ._, .v_pd, .cvtdq2, .dst0y, .dst0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size_up_8), ._, ._ },
                        .{ .@"0:", .vp_d, .movsxw, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, .v_pd, .cvtdq2, .tmp1y, .tmp1x, ._, ._ },
                        .{ ._, .v_pd, .mova, .memsi(.dst0y, .@"4", .tmp0), .tmp1y, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size_up_4), ._, ._ },
                        .{ .@"0:", .v_d, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, .vp_d, .movsxw, .tmp1x, .tmp1q, ._, ._ },
                        .{ ._, .v_pd, .cvtdq2, .tmp1x, .tmp1q, ._, ._ },
                        .{ ._, .v_pd, .mova, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size_up_4), ._, ._ },
                        .{ .@"0:", ._d, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, .p_d, .movsxw, .tmp1x, .tmp1q, ._, ._ },
                        .{ ._, ._pd, .cvtdq2, .tmp1x, .tmp1q, ._, ._ },
                        .{ ._, ._pd, .mova, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size_up_8), ._, ._ },
                        .{ .@"0:", .vp_d, .movzxw, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, .v_pd, .cvtdq2, .tmp1y, .tmp1x, ._, ._ },
                        .{ ._, .v_pd, .mova, .memsi(.dst0y, .@"4", .tmp0), .tmp1y, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size_up_4), ._, ._ },
                        .{ .@"0:", .v_d, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, .vp_d, .movzxw, .tmp1x, .tmp1q, ._, ._ },
                        .{ ._, .v_pd, .cvtdq2, .tmp1x, .tmp1q, ._, ._ },
                        .{ ._, .v_pd, .mova, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size_up_4), ._, ._ },
                        .{ .@"0:", ._d, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, .p_d, .movzxw, .tmp1x, .tmp1q, ._, ._ },
                        .{ ._, ._pd, .cvtdq2, .tmp1x, .tmp1q, ._, ._ },
                        .{ ._, ._pd, .mova, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_sd, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._sd, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ps, .movl, .memsi(.dst0q, .@"4", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_sd, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._sd, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ps, .movl, .memsi(.dst0q, .@"4", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_pd, .cvtdq2, .dst0x, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._pd, .cvtdq2, .dst0x, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_pd, .cvtdq2, .dst0y, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size_up_16), ._, ._ },
                        .{ .@"0:", .v_pd, .cvtdq2, .tmp1y, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, .v_pd, .mova, .memsi(.dst0y, .@"2", .tmp0), .tmp1y, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size_up_8), ._, ._ },
                        .{ .@"0:", .v_pd, .cvtdq2, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, .v_pd, .mova, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size_up_8), ._, ._ },
                        .{ .@"0:", ._pd, .cvtdq2, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._pd, .mova, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_sd, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._sd, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ps, .movl, .memsi(.dst0q, .@"2", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_sd, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._sd, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ps, .movl, .memsi(.dst0q, .@"2", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_pd, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
                        .{ ._, .v_sd, .cvtsi2, .tmp1x, .tmp1x, .memi(.src0q, .tmp0), ._ },
                        .{ ._, .v_sd, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse2, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._pd, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._sd, .cvtsi2, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._sd, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatdidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_sd, .mov, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse2, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatdidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._sd, .mov, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatdidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ps, .movl, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatundidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_sd, .mov, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse2, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatundidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._sd, .mov, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatundidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ps, .movl, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floattidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"2", .tmp0, 8), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_sd, .mov, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floattidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_sd, .mov, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floattidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"2", .tmp0, 8), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._sd, .mov, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floattidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._sd, .mov, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floattidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"2", .tmp0, 8), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ps, .movl, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floattidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ps, .movl, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"2", .tmp0, 8), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_sd, .mov, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_sd, .mov, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"2", .tmp0, 8), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._sd, .mov, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._sd, .mov, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"2", .tmp0, 8), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ps, .movl, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ps, .movl, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floateidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, .v_sd, .mov, .memi(.dst0q, .tmp1), .tmp5x, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse2, null, null },
                    .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floateidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._sd, .mov, .memi(.dst0q, .tmp1), .tmp5x, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floateidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._ps, .movl, .memi(.dst0q, .tmp1), .tmp5x, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuneidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, .v_sd, .mov, .memi(.dst0q, .tmp1), .tmp5x, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse2, null, null },
                    .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuneidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._sd, .mov, .memi(.dst0q, .tmp1), .tmp5x, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuneidf" } },
                        .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._ps, .movl, .memi(.dst0q, .tmp1), .tmp5x, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .byte }, .any, .any },
                    .dst_constraints = .{ .{ .float = .tbyte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .{ .type = .i16, .kind = .mem },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1w, .tmp0w, ._, ._ },
                        .{ ._, .fi_, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any },
                    .dst_constraints = .{ .{ .float = .tbyte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .{ .type = .i16, .kind = .mem },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ },
                        .{ ._, ._, .mov, .tmp1w, .tmp0w, ._, ._ },
                        .{ ._, .fi_, .ld, .tmp1w, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .signed_or_exclusive_int = .word }, .any, .any },
                    .dst_constraints = .{ .{ .float = .tbyte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .fi_, .ld, .src0w, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .exact_unsigned_int = 16 }, .any, .any },
                    .dst_constraints = .{ .{ .float = .tbyte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .{ .type = .i32, .kind = .mem },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, .fi_, .ld, .tmp1d, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .tbyte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .fi_, .ld, .src0d, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .x87, null, null },
                    .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .any, .any },
                    .dst_constraints = .{ .{ .float = .tbyte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .i64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .{ .type = .i64, .kind = .mem },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, .fi_, .ld, .tmp1q, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .tbyte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .fi_, .ld, .src0q, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .gnu,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any },
                    .dst_constraints = .{ .{ .float = .tbyte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_f32, .kind = .f32_0_0x1p64_mem },
                        .{ .type = .u1, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .fi_, .ld, .src0q, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .memd(.src0d, 4), ._, ._ },
                        .{ ._, ._r, .sh, .tmp3d, .ui(31), ._, ._ },
                        .{ ._, .f_, .add, .leasi(.tmp1d, .@"4", .tmp3), ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_abi = .msvc,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any },
                    .dst_constraints = .{ .{ .float = .tbyte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .{ .type = .u1, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .mem },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_f32, .kind = .f32_0_0x1p64_mem },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .x87 }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .fi_, .ld, .src0q, ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .memd(.src0d, 4), ._, ._ },
                        .{ ._, ._r, .sh, .tmp1d, .ui(31), ._, ._ },
                        .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ },
                        .{ ._, ._, .movzx, .tmp3d, .memd(.tmp2b, 1), ._, ._ },
                        .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_00_11), ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
                        .{ ._, ._, .mov, .memd(.tmp2b, 1), .tmp3b, ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .mem(.tmp4), ._, ._ },
                        .{ ._, .f_, .add, .leasi(.tmp3d, .@"4", .tmp1), ._, ._, ._ },
                        .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ },
                        .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .xword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .tbyte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__floattixf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .reg = .st0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .src_constraints = .{ .{ .signed_int = .xword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .tbyte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floattixf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .tbyte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntixf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .reg = .st0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .tbyte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntixf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .float = .tbyte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floateixf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .reg = .st0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .float = .tbyte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floateixf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .float = .tbyte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuneixf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .reg = .st0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .float = .tbyte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuneixf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .mem },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp3w, .tmp2w, ._, ._ },
                        .{ ._, .fi_, .ld, .tmp3w, ._, ._, ._ },
                        .{ ._, .f_p, .st, .lea(.tmp1t), ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .mem },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp3w, .tmp2w, ._, ._ },
                        .{ ._, .fi_, .ld, .tmp3w, ._, ._, ._ },
                        .{ ._, .f_p, .st, .lea(.tmp1t), ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .mem },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp3w, .tmp2w, ._, ._ },
                        .{ ._, .fi_, .ld, .tmp3w, ._, ._, ._ },
                        .{ ._, .f_p, .st, .lea(.tmp1t), ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i16, .kind = .mem },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp3w, .tmp2w, ._, ._ },
                        .{ ._, .fi_, .ld, .tmp3w, ._, ._, ._ },
                        .{ ._, .f_p, .st, .lea(.tmp1t), ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .x87, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsixf" } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .lea(.tmp1t), ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsixf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                        .{ ._, ._, .movsx, .tmp3d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsixf" } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .lea(.tmp1t), ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsixf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                        .{ ._, ._, .movsx, .tmp3d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .x87, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsixf" } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .lea(.tmp1t), ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .slow_incdec, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsixf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                        .{ ._, ._, .movzx, .tmp3d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsixf" } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .lea(.tmp1t), ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsixf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
                        .{ ._, ._, .movzx, .tmp3d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .fi_, .ld, .memi(.src0w, .tmp0), ._, ._, ._ },
                        .{ ._, .f_p, .st, .memsi(.dst0t, .@"8", .tmp0), ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsixf" } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .memsi(.dst0t, .@"8", .tmp0), ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsixf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.dst0, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .movsx, .tmp2d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsixf" } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .memsi(.dst0t, .@"8", .tmp0), ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsixf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.dst0, .@"8", .tmp0), ._, ._ },
                        .{ ._, ._, .movzx, .tmp2d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .fi_, .ld, .memi(.src0d, .tmp0), ._, ._, ._ },
                        .{ ._, .f_p, .st, .memsi(.dst0t, .@"4", .tmp0), ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsixf" } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .memsi(.dst0t, .@"4", .tmp0), ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsixf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.dst0, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsixf" } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .memsi(.dst0t, .@"4", .tmp0), ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsixf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.dst0, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .fi_, .ld, .memi(.src0q, .tmp0), ._, ._, ._ },
                        .{ ._, .f_p, .st, .memsi(.dst0t, .@"2", .tmp0), ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatdixf" } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .memsi(.dst0t, .@"2", .tmp0), ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatdixf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.dst0, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatundixf" } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .memsi(.dst0t, .@"2", .tmp0), ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatundixf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memsi(.dst0, .@"2", .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floattixf" } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q0, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q1, .memid(.src0q, .tmp0, 8), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .memi(.dst0t, .tmp0), ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floattixf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.dst0, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntixf" } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q0, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q1, .memid(.src0q, .tmp0, 8), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .memi(.dst0t, .tmp0), ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntixf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.dst0, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floateixf" } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .memi(.dst0t, .tmp1), ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floateixf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp2p, .memi(.dst0, .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3p, .tmp0p, ._, ._ },
                        .{ ._, ._, .mov, .tmp4d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .x87, null, null, null },
                    .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuneixf" } },
                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .memi(.dst0t, .tmp1), ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuneixf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp2p, .memi(.dst0, .tmp1), ._, ._ },
                        .{ ._, ._, .mov, .tmp3p, .tmp0p, ._, ._ },
                        .{ ._, ._, .mov, .tmp4d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .byte }, .any, .any },
                    .dst_constraints = .{ .{ .float = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any },
                    .dst_constraints = .{ .{ .float = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .word }, .any, .any },
                    .dst_constraints = .{ .{ .float = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movsx, .tmp0d, .src0w, ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any },
                    .dst_constraints = .{ .{ .float = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .dword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatditf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunditf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .xword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__floattitf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .signed_int = .xword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floattitf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntitf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any },
                    .dst_constraints = .{ .{ .float = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntitf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .float = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floateitf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .float = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuneitf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .lea(.tmp1x), .tmp4x, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .lea(.tmp1x), .tmp4x, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .lea(.tmp1x), .tmp4x, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .lea(.tmp1x), .tmp4x, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .lea(.tmp1x), .tmp4x, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .lea(.tmp1x), .tmp4x, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .lea(.tmp1x), .tmp4x, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .lea(.tmp1x), .tmp4x, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .lea(.tmp1x), .tmp4x, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .lea(.tmp1x), .tmp4x, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, .slow_incdec, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .lea(.tmp1x), .tmp4x, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .lea(.tmp1x), .tmp4x, ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"8", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"8", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memsi(.dst0x, .@"8", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"8", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"8", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memsi(.dst0x, .@"8", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"4", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"4", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memsi(.dst0x, .@"4", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"4", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"4", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memsi(.dst0x, .@"4", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatditf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"2", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse2, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatditf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"2", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatditf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memsi(.dst0x, .@"2", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunditf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"2", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse2, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunditf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"2", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatunditf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memsi(.dst0x, .@"2", .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floattitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q0, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q1, .memid(.src0q, .tmp0, 8), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floattitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floattitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q0, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q1, .memid(.src0q, .tmp0, 8), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floattitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floattitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q0, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q1, .memid(.src0q, .tmp0, 8), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floattitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q0, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q1, .memid(.src0q, .tmp0, 8), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q0, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q1, .memid(.src0q, .tmp0, 8), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q0, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q1, .memid(.src0q, .tmp0, 8), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuntitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floateitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp1), .tmp5x, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse2, null, null },
                    .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floateitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp1), .tmp5x, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floateitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp1), .tmp5x, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuneitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp1), .tmp5x, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse2, null, null },
                    .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuneitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp1), .tmp5x, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__floatuneitf" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp1), .tmp5x, ._, ._ },
                        .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f} {f}", .{
                        @tagName(air_tag),
                        ty_op.ty.toType().fmt(pt),
                        cg.typeOf(ty_op.operand).fmt(pt),
                        ops[0].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{ty_op.operand}, &ops, cg);
            },
            .reduce => |air_tag| {
                const nan = std.math.nan(f16);
                const reduce = air_datas[@intFromEnum(inst)].reduce;
                const res_ty = cg.typeOfIndex(inst);
                var ops = try cg.tempsFromOperands(inst, .{reduce.operand});
                var res: [1]Temp = undefined;
                cg.select(&res, &.{res_ty}, &ops, switch (reduce.operation) {
                    .And, .Or, .Xor => switch (@as(Mir.Inst.Tag, switch (reduce.operation) {
                        else => unreachable,
                        .And => .@"and",
                        .Or => .@"or",
                        .Xor => .xor,
                    })) {
                        else => unreachable,
                        inline .@"and", .@"or", .xor => |mir_tag| comptime &switch (mir_tag) {
                            else => unreachable,
                            .@"and" => [_]Select.Case{ .{
                                .required_features = .{ .avx, null, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .any_bool_vec, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .{ .all_reg_mask = .{ .size = .xword, .is = .inverted } }, .none, .none } },
                                },
                                .dst_temps = .{ .{ .cc = .z }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, .vp_, .@"test", .src0x, .src0x, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .sse4_1, null, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .any_bool_vec, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .{ .all_reg_mask = .{ .size = .xword, .is = .inverted } }, .none, .none } },
                                },
                                .dst_temps = .{ .{ .cc = .z }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, .p_, .@"test", .src0x, .src0x, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .avx, null, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .any_bool_vec, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .{ .all_reg_mask = .{ .size = .xword } }, .none, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .ptest_cc = .{ .ref = .src0, .all = 1 } }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, .vp_b, .cmpeq, .tmp0x, .tmp0x, .tmp0x, ._ },
                                    .{ ._, .vp_, .@"test", .src0x, .tmp0x, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .sse4_1, null, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .any_bool_vec, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .{ .all_reg_mask = .{ .size = .xword } }, .none, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .ptest_cc = .{ .ref = .src0, .all = 1 } }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, .p_b, .cmpeq, .tmp0x, .tmp0x, ._, ._ },
                                    .{ ._, .p_, .@"test", .src0x, .tmp0x, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .avx, null, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .any_bool_vec, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .{ .reg_mask = .{ .size = .xword } }, .none, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .vector_16_u8, .kind = .{ .ptest_mask_mem = .src0 } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .ptest_cc = .{ .ref = .src0, .all = 1 } }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                    .{ ._, .vp_, .@"test", .src0x, .lea(.tmp0x), ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .sse4_1, null, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .any_bool_vec, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .{ .reg_mask = .{ .size = .xword } }, .none, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .vector_16_u8, .kind = .{ .ptest_mask_mem = .src0 } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .ptest_cc = .{ .ref = .src0, .all = 1 } }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                    .{ ._, .p_, .@"test", .src0x, .lea(.tmp0x), ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .avx2, null, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .any_bool_vec, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .{ .all_reg_mask = .{ .size = .yword, .is = .inverted } }, .none, .none } },
                                },
                                .dst_temps = .{ .{ .cc = .z }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, .vp_, .@"test", .src0y, .src0y, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .avx, null, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .any_bool_vec, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .{ .all_reg_mask = .{ .size = .yword, .is = .inverted } }, .none, .none } },
                                },
                                .dst_temps = .{ .{ .cc = .z }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, .v_ps, .@"test", .src0y, .src0y, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .avx2, null, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .any_bool_vec, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .{ .all_reg_mask = .{ .size = .yword } }, .none, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .ptest_cc = .{ .ref = .src0, .all = 1 } }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, .vp_b, .cmpeq, .tmp0y, .tmp0y, .tmp0y, ._ },
                                    .{ ._, .vp_, .@"test", .src0y, .tmp0y, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .avx, null, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .any_bool_vec, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .{ .all_reg_mask = .{ .size = .yword } }, .none, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .ptest_cc = .{ .ref = .src0, .all = 1 } }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, .v_ps, .cmp, .tmp0y, .tmp0y, .tmp0y, .vp(.true) },
                                    .{ ._, .v_ps, .@"test", .src0y, .tmp0y, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .avx, null, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .any_bool_vec, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .{ .reg_mask = .{ .size = .yword } }, .none, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .vector_32_u8, .kind = .{ .ptest_mask_mem = .src0 } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .ptest_cc = .{ .ref = .src0, .all = 1 } }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                    .{ ._, .vp_, .@"test", .src0y, .lea(.tmp0y), ._, ._ },
                                } },
                            }, .{
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .exact_bool_vec = 8 }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .mem, .none, .none } },
                                    .{ .src = .{ .to_gpr, .none, .none } },
                                },
                                .dst_temps = .{ .{ .cc = .e }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .cmp, .src0b, .si(-1), ._, ._ },
                                } },
                            }, .{
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .bool_vec = .byte }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_mut_gpr, .none, .none } },
                                },
                                .dst_temps = .{ .{ .cc = .z }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .not, .src0b, ._, ._, ._ },
                                    .{ ._, ._, .@"test", .src0b, .ua(.src0, .add_umax), ._, ._ },
                                } },
                            }, .{
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .exact_bool_vec = 16 }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .mem, .none, .none } },
                                    .{ .src = .{ .to_gpr, .none, .none } },
                                },
                                .dst_temps = .{ .{ .cc = .e }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .cmp, .src0w, .si(-1), ._, ._ },
                                } },
                            }, .{
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .bool_vec = .word }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_mut_gpr, .none, .none } },
                                },
                                .dst_temps = .{ .{ .cc = .z }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .not, .src0d, ._, ._, ._ },
                                    .{ ._, ._, .@"test", .src0d, .ua(.src0, .add_umax), ._, ._ },
                                } },
                            }, .{
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .exact_bool_vec = 32 }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .mem, .none, .none } },
                                    .{ .src = .{ .to_gpr, .none, .none } },
                                },
                                .dst_temps = .{ .{ .cc = .e }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .cmp, .src0d, .si(-1), ._, ._ },
                                } },
                            }, .{
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .bool_vec = .dword }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_mut_gpr, .none, .none } },
                                },
                                .dst_temps = .{ .{ .cc = .z }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .not, .src0d, ._, ._, ._ },
                                    .{ ._, ._, .@"test", .src0d, .ua(.src0, .add_umax), ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .@"64bit", null, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .exact_bool_vec = 64 }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .mem, .none, .none } },
                                    .{ .src = .{ .to_gpr, .none, .none } },
                                },
                                .dst_temps = .{ .{ .cc = .e }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .cmp, .src0q, .si(-1), ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .@"64bit", null, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .bool_vec = .qword }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_mut_gpr, .none, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .cc = .z }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .not, .src0q, ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ },
                                    .{ ._, ._, .@"test", .src0q, .tmp0q, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .@"64bit", null, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .exact_remainder_bool_vec = .{ .of = .qword, .is = 64 } }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .none, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .cc = .nc }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_bit_size_div_8), ._, ._ },
                                    .{ .@"1:", ._, .cmp, .memi(.src0q, .tmp0), .si(-1), ._, ._ },
                                    .{ ._, ._ne, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._, .add, .tmp0d, .si(-8), ._, ._ },
                                    .{ ._, ._b, .j, .@"1b", ._, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .@"64bit", null, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .remainder_bool_vec = .{ .of = .qword, .is = .qword } }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .none, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .cc = .nc }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_2_smin), ._, ._ },
                                    .{ ._, ._, .@"or", .tmp0q, .mema(.src0q, .add_bit_size_div_8_down_8), ._, ._ },
                                    .{ ._, ._, .cmp, .tmp0q, .si(-1), ._, ._ },
                                    .{ ._, ._ne, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_bit_size_div_8_down_8), ._, ._ },
                                    .{ .@"1:", ._, .cmp, .memi(.src0q, .tmp0), .si(-1), ._, ._ },
                                    .{ ._, ._ne, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._, .add, .tmp0d, .si(-8), ._, ._ },
                                    .{ ._, ._b, .j, .@"1b", ._, ._, ._ },
                                } },
                            } },
                            .@"or" => [_]Select.Case{ .{
                                .required_features = .{ .avx, null, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .any_bool_vec, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .{ .all_reg_mask = .{ .size = .xword, .is = .uninverted } }, .none, .none } },
                                },
                                .dst_temps = .{ .{ .cc = .nz }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, .vp_, .@"test", .src0x, .src0x, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .sse4_1, null, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .any_bool_vec, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .{ .all_reg_mask = .{ .size = .xword, .is = .uninverted } }, .none, .none } },
                                },
                                .dst_temps = .{ .{ .cc = .nz }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, .p_, .@"test", .src0x, .src0x, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .avx, null, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .any_bool_vec, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .{ .all_reg_mask = .{ .size = .xword } }, .none, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .ptest_cc = .{ .ref = .src0, .not = true, .all = 0 } }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, .vp_b, .cmpeq, .tmp0x, .tmp0x, .tmp0x, ._ },
                                    .{ ._, .vp_, .@"test", .src0x, .tmp0x, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .sse4_1, null, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .any_bool_vec, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .{ .all_reg_mask = .{ .size = .xword } }, .none, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .ptest_cc = .{ .ref = .src0, .not = true, .all = 0 } }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, .p_b, .cmpeq, .tmp0x, .tmp0x, ._, ._ },
                                    .{ ._, .p_, .@"test", .src0x, .tmp0x, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .avx, null, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .any_bool_vec, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .{ .reg_mask = .{ .size = .xword } }, .none, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .vector_16_u8, .kind = .{ .ptest_mask_mem = .src0 } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .ptest_cc = .{ .ref = .src0, .not = true, .all = 0 } }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                    .{ ._, .vp_, .@"test", .src0x, .lea(.tmp0x), ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .sse4_1, null, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .any_bool_vec, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .{ .reg_mask = .{ .size = .xword } }, .none, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .vector_16_u8, .kind = .{ .ptest_mask_mem = .src0 } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .ptest_cc = .{ .ref = .src0, .not = true, .all = 0 } }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                    .{ ._, .p_, .@"test", .src0x, .lea(.tmp0x), ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .avx2, null, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .any_bool_vec, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .{ .all_reg_mask = .{ .size = .yword, .is = .uninverted } }, .none, .none } },
                                },
                                .dst_temps = .{ .{ .cc = .nz }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, .vp_, .@"test", .src0y, .src0y, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .avx, null, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .any_bool_vec, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .{ .all_reg_mask = .{ .size = .yword, .is = .uninverted } }, .none, .none } },
                                },
                                .dst_temps = .{ .{ .cc = .nz }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, .v_ps, .@"test", .src0y, .src0y, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .avx2, null, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .any_bool_vec, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .{ .all_reg_mask = .{ .size = .yword } }, .none, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .ptest_cc = .{ .ref = .src0, .not = true, .all = 0 } }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, .vp_b, .cmpeq, .tmp0y, .tmp0y, .tmp0y, ._ },
                                    .{ ._, .vp_, .@"test", .src0y, .tmp0y, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .avx, null, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .any_bool_vec, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .{ .all_reg_mask = .{ .size = .yword } }, .none, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .ptest_cc = .{ .ref = .src0, .not = true, .all = 0 } }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, .v_ps, .cmp, .tmp0y, .tmp0y, .tmp0y, .vp(.true) },
                                    .{ ._, .v_ps, .@"test", .src0y, .tmp0y, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .avx, null, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .any_bool_vec, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .{ .reg_mask = .{ .size = .yword } }, .none, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .vector_32_u8, .kind = .{ .ptest_mask_mem = .src0 } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .ptest_cc = .{ .ref = .src0, .not = true, .all = 0 } }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                    .{ ._, .vp_, .@"test", .src0y, .lea(.tmp0y), ._, ._ },
                                } },
                            }, .{
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .exact_bool_vec = 8 }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .mem, .none, .none } },
                                },
                                .dst_temps = .{ .{ .cc = .ne }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .cmp, .src0b, .si(0), ._, ._ },
                                } },
                            }, .{
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .exact_bool_vec = 8 }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_gpr, .none, .none } },
                                },
                                .dst_temps = .{ .{ .cc = .nz }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .@"test", .src0b, .src0b, ._, ._ },
                                } },
                            }, .{
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .bool_vec = .byte }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .mem, .none, .none } },
                                    .{ .src = .{ .to_gpr, .none, .none } },
                                },
                                .dst_temps = .{ .{ .cc = .nz }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .@"test", .src0b, .ua(.src0, .add_umax), ._, ._ },
                                } },
                            }, .{
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .exact_bool_vec = 16 }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .mem, .none, .none } },
                                },
                                .dst_temps = .{ .{ .cc = .ne }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .cmp, .src0w, .si(0), ._, ._ },
                                } },
                            }, .{
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .exact_bool_vec = 16 }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_gpr, .none, .none } },
                                },
                                .dst_temps = .{ .{ .cc = .nz }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .@"test", .src0w, .src0w, ._, ._ },
                                } },
                            }, .{
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .bool_vec = .word }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .mem, .none, .none } },
                                    .{ .src = .{ .to_gpr, .none, .none } },
                                },
                                .dst_temps = .{ .{ .cc = .nz }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .@"test", .src0w, .ua(.src0, .add_umax), ._, ._ },
                                } },
                            }, .{
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .exact_bool_vec = 32 }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .mem, .none, .none } },
                                },
                                .dst_temps = .{ .{ .cc = .ne }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .cmp, .src0d, .si(0), ._, ._ },
                                } },
                            }, .{
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .exact_bool_vec = 32 }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_gpr, .none, .none } },
                                },
                                .dst_temps = .{ .{ .cc = .nz }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .@"test", .src0d, .src0d, ._, ._ },
                                } },
                            }, .{
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .bool_vec = .dword }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .mem, .none, .none } },
                                    .{ .src = .{ .to_gpr, .none, .none } },
                                },
                                .dst_temps = .{ .{ .cc = .nz }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .@"test", .src0d, .ua(.src0, .add_umax), ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .@"64bit", null, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .exact_bool_vec = 64 }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .mem, .none, .none } },
                                },
                                .dst_temps = .{ .{ .cc = .ne }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .cmp, .src0q, .si(0), ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .@"64bit", null, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .exact_bool_vec = 64 }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_gpr, .none, .none } },
                                },
                                .dst_temps = .{ .{ .cc = .nz }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .@"test", .src0q, .src0q, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .@"64bit", null, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .bool_vec = .qword }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .mem, .none, .none } },
                                    .{ .src = .{ .to_gpr, .none, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .cc = .nz }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ },
                                    .{ ._, ._, .@"test", .src0q, .tmp0q, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .@"64bit", null, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .exact_remainder_bool_vec = .{ .of = .qword, .is = 64 } }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .none, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .cc = .nc }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_bit_size_div_8), ._, ._ },
                                    .{ .@"1:", ._, .cmp, .memi(.src0q, .tmp0), .si(0), ._, ._ },
                                    .{ ._, ._ne, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                                    .{ ._, ._nb, .j, .@"1b", ._, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .@"64bit", null, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .remainder_bool_vec = .{ .of = .qword, .is = .qword } }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .none, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .cc = .nc }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ },
                                    .{ ._, ._, .@"test", .mema(.src0q, .add_bit_size_div_8_down_8), .tmp0q, ._, ._ },
                                    .{ ._, ._nz, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_bit_size_div_8_down_8), ._, ._ },
                                    .{ .@"1:", ._, .cmp, .memi(.src0q, .tmp0), .si(0), ._, ._ },
                                    .{ ._, ._ne, .j, .@"0f", ._, ._, ._ },
                                    .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                                    .{ ._, ._nb, .j, .@"1b", ._, ._, ._ },
                                } },
                            } },
                            .xor => [_]Select.Case{ .{
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .bool_vec = .byte }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .mem, .none, .none } },
                                },
                                .dst_temps = .{ .{ .cc = .po }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .@"test", .src0b, .ua(.src0, .add_umax), ._, ._ },
                                } },
                            }, .{
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .exact_bool_vec = 8 }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_gpr, .none, .none } },
                                },
                                .dst_temps = .{ .{ .cc = .po }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .@"test", .src0b, .src0b, ._, ._ },
                                } },
                            }, .{
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .bool_vec = .byte }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_gpr, .none, .none } },
                                },
                                .dst_temps = .{ .{ .cc = .po }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .@"test", .src0b, .ua(.src0, .add_umax), ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .popcnt, null, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .exact_bool_vec = 16 }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .mem, .none, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .cc = .nz }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                                    .{ ._, ._, .popcnt, .tmp0w, .src0w, ._, ._ },
                                    .{ ._, ._, .@"and", .tmp0b, .ui(1), ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .popcnt, null, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .exact_bool_vec = 16 }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_mut_gpr, .none, .none } },
                                },
                                .dst_temps = .{ .{ .cc = .nz }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .popcnt, .src0w, .src0w, ._, ._ },
                                    .{ ._, ._, .@"and", .src0b, .ui(1), ._, ._ },
                                } },
                            }, .{
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .exact_bool_vec = 16 }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_gpr, .none, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .cc = .po }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp0d, .ui(8), ._, ._ },
                                    .{ ._, ._, .xor, .tmp0b, .src0b, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .popcnt, .fast_imm16, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .bool_vec = .word }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_mut_gpr, .none, .none } },
                                },
                                .dst_temps = .{ .{ .cc = .nz }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .@"and", .src0w, .ua(.src0, .add_umax), ._, ._ },
                                    .{ ._, ._, .popcnt, .src0w, .src0w, ._, ._ },
                                    .{ ._, ._, .@"and", .src0b, .ui(1), ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .popcnt, null, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .bool_vec = .word }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_mut_gpr, .none, .none } },
                                },
                                .dst_temps = .{ .{ .cc = .nz }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .@"and", .src0d, .ua(.src0, .add_umax), ._, ._ },
                                    .{ ._, ._, .popcnt, .src0d, .src0d, ._, ._ },
                                    .{ ._, ._, .@"and", .src0b, .ui(1), ._, ._ },
                                } },
                            }, .{
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .bool_vec = .word }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_gpr, .none, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .cc = .po }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp0d, .ui(8), ._, ._ },
                                    .{ ._, ._, .@"and", .tmp0b, .ua(.src0b, .add_umax), ._, ._ },
                                    .{ ._, ._, .xor, .tmp0d, .src0d, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .popcnt, .false_deps_popcnt, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .exact_bool_vec = 32 }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .mem, .none, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .cc = .nz }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                                    .{ ._, ._, .popcnt, .tmp0d, .src0d, ._, ._ },
                                    .{ ._, ._, .@"and", .tmp0b, .ui(1), ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .popcnt, .false_deps_popcnt, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .exact_bool_vec = 32 }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_mut_gpr, .none, .none } },
                                },
                                .dst_temps = .{ .{ .cc = .nz }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .popcnt, .src0d, .src0d, ._, ._ },
                                    .{ ._, ._, .@"and", .src0b, .ui(1), ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .popcnt, null, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .exact_bool_vec = 32 }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .mem, .none, .none } },
                                    .{ .src = .{ .to_gpr, .none, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .u32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .cc = .nz }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .popcnt, .tmp0d, .src0d, ._, ._ },
                                    .{ ._, ._, .@"and", .tmp0b, .ui(1), ._, ._ },
                                } },
                            }, .{
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .exact_bool_vec = 32 }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_gpr, .none, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .cc = .po }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp0d, .ui(16), ._, ._ },
                                    .{ ._, ._, .xor, .tmp0d, .src0d, ._, ._ },
                                    .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1d, .ui(8), ._, ._ },
                                    .{ ._, ._, .xor, .tmp0b, .tmp1b, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .popcnt, null, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .bool_vec = .dword }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_mut_gpr, .none, .none } },
                                },
                                .dst_temps = .{ .{ .cc = .nz }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .@"and", .src0d, .ua(.src0, .add_umax), ._, ._ },
                                    .{ ._, ._, .popcnt, .src0d, .src0d, ._, ._ },
                                    .{ ._, ._, .@"and", .src0b, .ui(1), ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .fast_imm16, null, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .bool_vec = .dword }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_gpr, .none, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .cc = .po }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp0d, .ui(16), ._, ._ },
                                    .{ ._, ._, .@"and", .tmp0d, .ua(.src0w, .add_umax), ._, ._ },
                                    .{ ._, ._, .xor, .tmp0d, .src0d, ._, ._ },
                                    .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1d, .ui(8), ._, ._ },
                                    .{ ._, ._, .xor, .tmp0b, .tmp1b, ._, ._ },
                                } },
                            }, .{
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .bool_vec = .dword }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_gpr, .none, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .cc = .po }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp0d, .ui(16), ._, ._ },
                                    .{ ._, ._, .@"and", .tmp0d, .ua(.src0w, .add_umax), ._, ._ },
                                    .{ ._, ._, .xor, .tmp0d, .src0d, ._, ._ },
                                    .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1d, .ui(8), ._, ._ },
                                    .{ ._, ._, .xor, .tmp0b, .tmp1b, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .@"64bit", .popcnt, .false_deps_popcnt, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .exact_bool_vec = 64 }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .mem, .none, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .cc = .nz }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                                    .{ ._, ._, .popcnt, .tmp0q, .src0q, ._, ._ },
                                    .{ ._, ._, .@"and", .tmp0b, .ui(1), ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .@"64bit", .popcnt, .false_deps_popcnt, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .exact_bool_vec = 64 }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_mut_gpr, .none, .none } },
                                },
                                .dst_temps = .{ .{ .cc = .nz }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .popcnt, .src0q, .src0q, ._, ._ },
                                    .{ ._, ._, .@"and", .src0b, .ui(1), ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .@"64bit", .popcnt, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .exact_bool_vec = 64 }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .mem, .none, .none } },
                                    .{ .src = .{ .to_gpr, .none, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .u64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .cc = .nz }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .popcnt, .tmp0q, .src0q, ._, ._ },
                                    .{ ._, ._, .@"and", .tmp0b, .ui(1), ._, ._ },
                                } },
                            }, .{
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .exact_bool_vec = 64 }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_gpr, .none, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .cc = .po }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp0q, .ui(32), ._, ._ },
                                    .{ ._, ._, .xor, .tmp0d, .src0d, ._, ._ },
                                    .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1d, .ui(16), ._, ._ },
                                    .{ ._, ._, .xor, .tmp0d, .tmp1d, ._, ._ },
                                    .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1d, .ui(8), ._, ._ },
                                    .{ ._, ._, .xor, .tmp0b, .tmp1b, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .@"64bit", .popcnt, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .bool_vec = .qword }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .mem, .none, .none } },
                                    .{ .src = .{ .to_gpr, .none, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .cc = .nz }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ },
                                    .{ ._, ._, .@"and", .tmp0q, .src0q, ._, ._ },
                                    .{ ._, ._, .popcnt, .tmp0q, .tmp0q, ._, ._ },
                                    .{ ._, ._, .@"and", .tmp0b, .ui(1), ._, ._ },
                                } },
                            }, .{
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .bool_vec = .qword }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_gpr, .none, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .cc = .po }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp0q, .ui(32), ._, ._ },
                                    .{ ._, ._, .@"and", .tmp0d, .ua(.src0d, .add_umax), ._, ._ },
                                    .{ ._, ._, .xor, .tmp0d, .src0d, ._, ._ },
                                    .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1d, .ui(16), ._, ._ },
                                    .{ ._, ._, .xor, .tmp0d, .tmp1d, ._, ._ },
                                    .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1d, .ui(8), ._, ._ },
                                    .{ ._, ._, .xor, .tmp0b, .tmp1b, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .@"64bit", .popcnt, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .exact_remainder_bool_vec = .{ .of = .qword, .is = 64 } }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .none, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .cc = .nz }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_bit_size_div_8), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1q, .tmp1q, ._, ._ },
                                    .{ .@"0:", ._, .xor, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                                    .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                                    .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                                    .{ ._, ._, .popcnt, .tmp1q, .tmp1q, ._, ._ },
                                    .{ ._, ._, .@"and", .tmp1b, .ui(1), ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .@"64bit", null, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .exact_remainder_bool_vec = .{ .of = .qword, .is = 64 } }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .none, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .cc = .po }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_bit_size_div_8), ._, ._ },
                                    .{ ._, ._, .xor, .tmp1q, .tmp1q, ._, ._ },
                                    .{ .@"0:", ._, .xor, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                                    .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                                    .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp0d, .tmp1d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1q, .ui(32), ._, ._ },
                                    .{ ._, ._, .xor, .tmp0d, .tmp1d, ._, ._ },
                                    .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1d, .ui(16), ._, ._ },
                                    .{ ._, ._, .xor, .tmp0d, .tmp1d, ._, ._ },
                                    .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1d, .ui(8), ._, ._ },
                                    .{ ._, ._, .xor, .tmp0b, .tmp1b, ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .@"64bit", .popcnt, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .remainder_bool_vec = .{ .of = .qword, .is = .qword } }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .none, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .cc = .nz }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ },
                                    .{ ._, ._, .mov, .tmp1d, .sia(-8, .src0, .add_bit_size_div_8_down_8), ._, ._ },
                                    .{ ._, ._, .@"and", .tmp0q, .mema(.src0q, .add_bit_size_div_8_down_8), ._, ._ },
                                    .{ .@"0:", ._, .xor, .tmp0q, .memi(.src0q, .tmp1), ._, ._ },
                                    .{ ._, ._, .sub, .tmp1d, .si(8), ._, ._ },
                                    .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                                    .{ ._, ._, .popcnt, .tmp0q, .tmp0q, ._, ._ },
                                    .{ ._, ._, .@"and", .tmp0b, .ui(1), ._, ._ },
                                } },
                            }, .{
                                .required_features = .{ .@"64bit", null, null, null },
                                .dst_constraints = .{ .bool, .any },
                                .src_constraints = .{ .{ .remainder_bool_vec = .{ .of = .qword, .is = .qword } }, .any, .any },
                                .patterns = &.{
                                    .{ .src = .{ .to_mem, .none, .none } },
                                },
                                .extra_temps = .{
                                    .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                                    .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                    .unused,
                                },
                                .dst_temps = .{ .{ .cc = .po }, .unused },
                                .clobbers = .{ .eflags = true },
                                .each = .{ .once = &.{
                                    .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ },
                                    .{ ._, ._, .mov, .tmp1d, .sia(-8, .src0, .add_bit_size_div_8_down_8), ._, ._ },
                                    .{ ._, ._, .@"and", .tmp0q, .mema(.src0q, .add_bit_size_div_8_down_8), ._, ._ },
                                    .{ .@"0:", ._, .xor, .tmp0q, .memi(.src0q, .tmp1), ._, ._ },
                                    .{ ._, ._, .sub, .tmp1d, .si(8), ._, ._ },
                                    .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                                    .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp0q, .ui(32), ._, ._ },
                                    .{ ._, ._, .xor, .tmp0d, .tmp1d, ._, ._ },
                                    .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1d, .ui(16), ._, ._ },
                                    .{ ._, ._, .xor, .tmp0d, .tmp1d, ._, ._ },
                                    .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ },
                                    .{ ._, ._r, .sh, .tmp1d, .ui(8), ._, ._ },
                                    .{ ._, ._, .xor, .tmp0b, .tmp1b, ._, ._ },
                                } },
                            } },
                        } ++ [_]Select.Case{ .{
                            .required_features = .{ .avx, null, null, null },
                            .dst_constraints = .{ .{ .int = .byte }, .any },
                            .src_constraints = .{ .{ .scalar_int = .{ .of = .word, .is = .byte } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .vp_w, .srl, .tmp0x, .src0x, .ui(8), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .src0x, .tmp0x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse2, null, null, null },
                            .dst_constraints = .{ .{ .int = .byte }, .any },
                            .src_constraints = .{ .{ .scalar_int = .{ .of = .word, .is = .byte } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mut_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .ref = .src0 }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, ._dqa, .mov, .tmp0x, .src0x, ._, ._ },
                                .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .dst_constraints = .{ .{ .int = .byte }, .any },
                            .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .src0x, .tmp0x, ._ },
                                .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse2, null, null, null },
                            .dst_constraints = .{ .{ .int = .byte }, .any },
                            .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mut_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .ref = .src0 }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ },
                                .{ ._, ._dqa, .mov, .tmp0x, .dst0x, ._, ._ },
                                .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .dst_constraints = .{ .{ .int = .byte }, .any },
                            .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                                .{ ._, .vp_, mir_tag, .tmp0x, .src0x, .tmp0x, ._ },
                                .{ ._, .vp_w, .srl, .dst0x, .src0x, .ui(8), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .tmp0x, .dst0x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse2, null, null, null },
                            .dst_constraints = .{ .{ .int = .byte }, .any },
                            .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mut_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .ref = .src0 }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                                .{ ._, .p_, mir_tag, .tmp0x, .src0x, ._, ._ },
                                .{ ._, .p_w, .srl, .dst0x, .ui(8), ._, ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .dst_constraints = .{ .{ .int = .byte }, .any },
                            .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .src0x, .tmp0x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                                .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse2, null, null, null },
                            .dst_constraints = .{ .{ .int = .byte }, .any },
                            .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mut_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .ref = .src0 }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ },
                                .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ },
                                .{ ._, ._dqa, .mov, .tmp0x, .dst0x, ._, ._ },
                                .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .dst_constraints = .{ .{ .int = .byte }, .any },
                            .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{
                                    .ref = .src0,
                                    .invert = switch (mir_tag) {
                                        else => unreachable,
                                        .@"and" => true,
                                        .@"or", .xor => false,
                                    },
                                } } },
                                .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                .{ ._, .vp_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .dst0x, .src0x, .lea(.tmp0x), ._ },
                                .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse2, null, null, null },
                            .dst_constraints = .{ .{ .int = .byte }, .any },
                            .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mut_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{
                                    .ref = .src0,
                                    .invert = switch (mir_tag) {
                                        else => unreachable,
                                        .@"and" => true,
                                        .@"or", .xor => false,
                                    },
                                } } },
                                .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .ref = .src0 }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                .{ ._, .p_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .dst0x, .lea(.tmp0x), ._, ._ },
                                .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ },
                                .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ },
                                .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
                                .{ ._, .p_w, .srl, .tmp2x, .ui(8), ._, ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .dst_constraints = .{ .{ .int = .byte }, .any },
                            .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .src0x, .tmp0x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                                .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse2, null, null, null },
                            .dst_constraints = .{ .{ .int = .byte }, .any },
                            .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mut_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .ref = .src0 }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ },
                                .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ },
                                .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ },
                                .{ ._, ._dqa, .mov, .tmp0x, .dst0x, ._, ._ },
                                .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .dst_constraints = .{ .{ .int = .byte }, .any },
                            .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{
                                    .ref = .src0,
                                    .invert = switch (mir_tag) {
                                        else => unreachable,
                                        .@"and" => true,
                                        .@"or", .xor => false,
                                    },
                                } } },
                                .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                .{ ._, .vp_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .dst0x, .src0x, .lea(.tmp0x), ._ },
                                .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse2, null, null, null },
                            .dst_constraints = .{ .{ .int = .byte }, .any },
                            .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mut_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{
                                    .ref = .src0,
                                    .invert = switch (mir_tag) {
                                        else => unreachable,
                                        .@"and" => true,
                                        .@"or", .xor => false,
                                    },
                                } } },
                                .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .ref = .src0 }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                .{ ._, .p_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .dst0x, .lea(.tmp0x), ._, ._ },
                                .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ },
                                .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ },
                                .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ },
                                .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
                                .{ ._, .p_w, .srl, .tmp2x, .ui(8), ._, ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx2, null, null, null },
                            .dst_constraints = .{ .{ .int = .byte }, .any },
                            .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .v_i128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .src0x, .tmp0x, ._ },
                                .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                                .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .dst_constraints = .{ .{ .int = .byte }, .any },
                            .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                                .{ ._, .v_ps, mir_tag, .dst0x, .src0x, .tmp0x, ._ },
                                .{ ._, .v_ps, .movhl, .tmp0x, .dst0x, .dst0x, ._ },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                                .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                                .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx2, null, null, null },
                            .dst_constraints = .{ .{ .int = .byte }, .any },
                            .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{
                                    .ref = .src0,
                                    .invert = switch (mir_tag) {
                                        else => unreachable,
                                        .@"and" => true,
                                        .@"or", .xor => false,
                                    },
                                } } },
                                .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                .{ ._, .vp_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .dst0y, .src0y, .lea(.tmp0y), ._ },
                                .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .dst_constraints = .{ .{ .int = .byte }, .any },
                            .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{
                                    .ref = .src0,
                                    .invert = switch (mir_tag) {
                                        else => unreachable,
                                        .@"and" => true,
                                        .@"or", .xor => false,
                                    },
                                } } },
                                .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                .{ ._, .v_ps, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .dst0y, .src0y, .lea(.tmp0y), ._ },
                                .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .v_ps, .movhl, .tmp2x, .dst0x, .dst0x, ._ },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b01) },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx512f, null, null, null },
                            .dst_constraints = .{ .{ .int = .byte }, .any },
                            .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .zword, .is = .byte } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
                                .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .memd(.src0y, 32), ._ },
                                .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                                .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                                .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx512f, null, null, null },
                            .dst_constraints = .{ .{ .int = .byte }, .any },
                            .src_constraints = .{ .{ .scalar_int = .{ .of = .zword, .is = .byte } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{
                                    .ref = .src0,
                                    .invert = switch (mir_tag) {
                                        else => unreachable,
                                        .@"and" => true,
                                        .@"or", .xor => false,
                                    },
                                } } },
                                .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
                                .{ ._, .v_dqa, .mov, .tmp2y, .memd(.src0y, 32), ._, ._ },
                                .{ ._, .vp_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .dst0y, .dst0y, .lea(.tmp0y), ._ },
                                .{ ._, .vp_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .tmp2y, .tmp2y, .lead(.tmp0y, 32), ._ },
                                .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .tmp2y, ._ },
                                .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx2, null, null, null },
                            .dst_constraints = .{ .{ .int = .byte }, .any },
                            .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                                .{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                                .{ .@"0:", .vp_, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                                .{ ._, .v_i128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
                                .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
                                .{ ._, .vp_w, .srl, .tmp1x, .dst0x, .ui(8), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .dst_constraints = .{ .{ .int = .byte }, .any },
                            .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                                .{ ._, .v_ps, .mova, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                                .{ .@"0:", .v_ps, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                                .{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
                                .{ ._, .v_ps, .movhl, .tmp1x, .dst0x, .dst0x, ._ },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
                                .{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b01) },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
                                .{ ._, .vp_w, .srl, .tmp1x, .dst0x, .ui(8), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse2, null, null, null },
                            .dst_constraints = .{ .{ .int = .byte }, .any },
                            .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                                .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                                .{ .@"0:", .p_, mir_tag, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                                .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp1x, ._, ._ },
                                .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp1x, ._, ._ },
                                .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp1x, ._, ._ },
                                .{ ._, ._dqa, .mov, .tmp1x, .dst0x, ._, ._ },
                                .{ ._, .p_w, .srl, .tmp1x, .ui(8), ._, ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp1x, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx512f, null, null, null },
                            .dst_constraints = .{ .{ .int = .byte }, .any },
                            .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .zword, .is = .byte } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{
                                    .ref = .src0,
                                    .invert = switch (mir_tag) {
                                        else => unreachable,
                                        .@"and" => true,
                                        .@"or", .xor => false,
                                    },
                                } } },
                                .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                                .{ ._, .v_dqa, .mov, .tmp2y, .lead(.tmp0y, 32), ._, ._ },
                                .{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ },
                                .{ ._, .vp_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .tmp2y, .tmp2y, .memad(.src0y, .add_size, -32), ._ },
                                .{ ._, .vp_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                                .{ .@"0:", .vp_, mir_tag, .tmp2y, .tmp2y, .memid(.src0y, .tmp0, 32), ._ },
                                .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                                .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .tmp2y, ._ },
                                .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx2, null, null, null },
                            .dst_constraints = .{ .{ .int = .byte }, .any },
                            .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{
                                    .ref = .src0,
                                    .invert = switch (mir_tag) {
                                        else => unreachable,
                                        .@"and" => true,
                                        .@"or", .xor => false,
                                    },
                                } } },
                                .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                                .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
                                .{ ._, .vp_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                                .{ .@"0:", .vp_, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                                .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .dst_constraints = .{ .{ .int = .byte }, .any },
                            .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{
                                    .ref = .src0,
                                    .invert = switch (mir_tag) {
                                        else => unreachable,
                                        .@"and" => true,
                                        .@"or", .xor => false,
                                    },
                                } } },
                                .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                                .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
                                .{ ._, .v_ps, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                                .{ .@"0:", .v_ps, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                                .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .v_ps, .movhl, .tmp2x, .dst0x, .dst0x, ._ },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b01) },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse2, null, null, null },
                            .dst_constraints = .{ .{ .int = .byte }, .any },
                            .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{
                                    .ref = .src0,
                                    .invert = switch (mir_tag) {
                                        else => unreachable,
                                        .@"and" => true,
                                        .@"or", .xor => false,
                                    },
                                } } },
                                .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ },
                                .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                                .{ ._, .p_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                                .{ .@"0:", .p_, mir_tag, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                                .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ },
                                .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ },
                                .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ },
                                .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
                                .{ ._, .p_w, .srl, .tmp2x, .ui(8), ._, ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .slow_incdec, null, null, null },
                            .dst_constraints = .{ .{ .int = .byte }, .any },
                            .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                                .{ ._, ._, .movzx, .dst0d, .memad(.src0b, .add_unaligned_size, -1), ._, ._ },
                                .{ .@"0:", ._, mir_tag, .dst0b, .memi(.src0b, .tmp0), ._, ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .dst_constraints = .{ .{ .int = .byte }, .any },
                            .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                                .{ ._, ._, .movzx, .dst0d, .memad(.src0b, .add_unaligned_size, -1), ._, ._ },
                                .{ .@"0:", ._, mir_tag, .dst0b, .memi(.src0b, .tmp0), ._, ._ },
                                .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                                .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .dst_constraints = .{ .{ .int = .word }, .any },
                            .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .word } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .src0x, .tmp0x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse2, null, null, null },
                            .dst_constraints = .{ .{ .int = .word }, .any },
                            .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .word } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mut_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .ref = .src0 }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .dst_constraints = .{ .{ .int = .word }, .any },
                            .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .qword, .is = .word } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .src0x, .tmp0x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse2, null, null, null },
                            .dst_constraints = .{ .{ .int = .word }, .any },
                            .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .qword, .is = .word } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mut_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .ref = .src0 }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ },
                                .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .dst_constraints = .{ .{ .int = .word }, .any },
                            .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .word } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .tmp0x, .src0x, .tmp0x, ._ },
                                .{ ._, .vp_w, .shufl, .dst0x, .src0x, .ui(0b01), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .tmp0x, .dst0x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse2, null, null, null },
                            .dst_constraints = .{ .{ .int = .word }, .any },
                            .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .word } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mut_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                                .{ ._, .p_, mir_tag, .tmp0x, .src0x, ._, ._ },
                                .{ ._, .p_w, .shufl, .dst0x, .src0x, .ui(0b01), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .dst_constraints = .{ .{ .int = .word }, .any },
                            .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .src0x, .tmp0x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse2, null, null, null },
                            .dst_constraints = .{ .{ .int = .word }, .any },
                            .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mut_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .ref = .src0 }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ },
                                .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ },
                                .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .dst_constraints = .{ .{ .int = .word }, .any },
                            .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{
                                    .ref = .src0,
                                    .invert = switch (mir_tag) {
                                        else => unreachable,
                                        .@"and" => true,
                                        .@"or", .xor => false,
                                    },
                                } } },
                                .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                .{ ._, .vp_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .dst0x, .src0x, .lea(.tmp0x), ._ },
                                .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse2, null, null, null },
                            .dst_constraints = .{ .{ .int = .word }, .any },
                            .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mut_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{
                                    .ref = .src0,
                                    .invert = switch (mir_tag) {
                                        else => unreachable,
                                        .@"and" => true,
                                        .@"or", .xor => false,
                                    },
                                } } },
                                .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .ref = .src0 }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                .{ ._, .p_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .dst0x, .lea(.tmp0x), ._, ._ },
                                .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ },
                                .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ },
                                .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx2, null, null, null },
                            .dst_constraints = .{ .{ .int = .word }, .any },
                            .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .v_i128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .src0x, .tmp0x, ._ },
                                .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .dst_constraints = .{ .{ .int = .word }, .any },
                            .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                                .{ ._, .v_ps, mir_tag, .dst0x, .src0x, .tmp0x, ._ },
                                .{ ._, .v_ps, .movhl, .tmp0x, .dst0x, .dst0x, ._ },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                                .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx2, null, null, null },
                            .dst_constraints = .{ .{ .int = .word }, .any },
                            .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{
                                    .ref = .src0,
                                    .invert = switch (mir_tag) {
                                        else => unreachable,
                                        .@"and" => true,
                                        .@"or", .xor => false,
                                    },
                                } } },
                                .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                .{ ._, .vp_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .dst0y, .src0y, .lea(.tmp0y), ._ },
                                .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .dst_constraints = .{ .{ .int = .word }, .any },
                            .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{
                                    .ref = .src0,
                                    .invert = switch (mir_tag) {
                                        else => unreachable,
                                        .@"and" => true,
                                        .@"or", .xor => false,
                                    },
                                } } },
                                .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                .{ ._, .v_ps, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .dst0y, .src0y, .lea(.tmp0y), ._ },
                                .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .v_ps, .movhl, .tmp2x, .dst0x, .dst0x, ._ },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b01) },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx512f, null, null, null },
                            .dst_constraints = .{ .{ .int = .word }, .any },
                            .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .zword, .is = .word } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
                                .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .memd(.src0y, 32), ._ },
                                .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                                .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx512f, null, null, null },
                            .dst_constraints = .{ .{ .int = .word }, .any },
                            .src_constraints = .{ .{ .scalar_int = .{ .of = .zword, .is = .word } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{
                                    .ref = .src0,
                                    .invert = switch (mir_tag) {
                                        else => unreachable,
                                        .@"and" => true,
                                        .@"or", .xor => false,
                                    },
                                } } },
                                .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
                                .{ ._, .v_dqa, .mov, .tmp2y, .memd(.src0y, 32), ._, ._ },
                                .{ ._, .vp_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .dst0y, .dst0y, .lea(.tmp0y), ._ },
                                .{ ._, .vp_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .tmp2y, .tmp2y, .lead(.tmp0y, 32), ._ },
                                .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .tmp2y, ._ },
                                .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx2, null, null, null },
                            .dst_constraints = .{ .{ .int = .word }, .any },
                            .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                                .{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                                .{ .@"0:", .vp_, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                                .{ ._, .v_i128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
                                .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .dst_constraints = .{ .{ .int = .word }, .any },
                            .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                                .{ ._, .v_ps, .mova, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                                .{ .@"0:", .v_ps, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                                .{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
                                .{ ._, .v_ps, .movhl, .tmp1x, .dst0x, .dst0x, ._ },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
                                .{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b01) },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse2, null, null, null },
                            .dst_constraints = .{ .{ .int = .word }, .any },
                            .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                                .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                                .{ .@"0:", .p_, mir_tag, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                                .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp1x, ._, ._ },
                                .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp1x, ._, ._ },
                                .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp1x, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx512f, null, null, null },
                            .dst_constraints = .{ .{ .int = .word }, .any },
                            .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .zword, .is = .word } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{
                                    .ref = .src0,
                                    .invert = switch (mir_tag) {
                                        else => unreachable,
                                        .@"and" => true,
                                        .@"or", .xor => false,
                                    },
                                } } },
                                .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                                .{ ._, .v_dqa, .mov, .tmp2y, .lead(.tmp0y, 32), ._, ._ },
                                .{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ },
                                .{ ._, .vp_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .tmp2y, .tmp2y, .memad(.src0y, .add_size, -32), ._ },
                                .{ ._, .vp_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                                .{ .@"0:", .vp_, mir_tag, .tmp2y, .tmp2y, .memid(.src0y, .tmp0, 32), ._ },
                                .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                                .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .tmp2y, ._ },
                                .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx2, null, null, null },
                            .dst_constraints = .{ .{ .int = .word }, .any },
                            .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{
                                    .ref = .src0,
                                    .invert = switch (mir_tag) {
                                        else => unreachable,
                                        .@"and" => true,
                                        .@"or", .xor => false,
                                    },
                                } } },
                                .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                                .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
                                .{ ._, .vp_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                                .{ .@"0:", .vp_, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                                .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .dst_constraints = .{ .{ .int = .word }, .any },
                            .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{
                                    .ref = .src0,
                                    .invert = switch (mir_tag) {
                                        else => unreachable,
                                        .@"and" => true,
                                        .@"or", .xor => false,
                                    },
                                } } },
                                .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                                .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
                                .{ ._, .v_ps, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                                .{ .@"0:", .v_ps, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                                .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .v_ps, .movhl, .tmp2x, .dst0x, .dst0x, ._ },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b01) },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse2, null, null, null },
                            .dst_constraints = .{ .{ .int = .word }, .any },
                            .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{
                                    .ref = .src0,
                                    .invert = switch (mir_tag) {
                                        else => unreachable,
                                        .@"and" => true,
                                        .@"or", .xor => false,
                                    },
                                } } },
                                .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ },
                                .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                                .{ ._, .p_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                                .{ .@"0:", .p_, mir_tag, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                                .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ },
                                .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ },
                                .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ },
                            } },
                        }, .{
                            .dst_constraints = .{ .{ .int = .word }, .any },
                            .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                                .{ ._, ._, .movzx, .dst0d, .memad(.src0w, .add_unaligned_size, -2), ._, ._ },
                                .{ .@"0:", ._, mir_tag, .dst0w, .memi(.src0w, .tmp0), ._, ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .dst_constraints = .{ .{ .int = .dword }, .any },
                            .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .dword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .src0x, .tmp0x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse2, null, null, null },
                            .dst_constraints = .{ .{ .int = .dword }, .any },
                            .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .dword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mut_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .ref = .src0 }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .dst_constraints = .{ .{ .int = .dword }, .any },
                            .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .src0x, .tmp0x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse2, null, null, null },
                            .dst_constraints = .{ .{ .int = .dword }, .any },
                            .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mut_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .ref = .src0 }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ },
                                .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .dst_constraints = .{ .{ .int = .dword }, .any },
                            .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .tmp0x, .src0x, .tmp0x, ._ },
                                .{ ._, .vp_w, .shufl, .dst0x, .src0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .tmp0x, .dst0x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse2, null, null, null },
                            .dst_constraints = .{ .{ .int = .dword }, .any },
                            .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                                .{ ._, .p_, mir_tag, .tmp0x, .src0x, ._, ._ },
                                .{ ._, .p_w, .shufl, .dst0x, .src0x, .ui(0b11_10), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx2, null, null, null },
                            .dst_constraints = .{ .{ .int = .dword }, .any },
                            .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .v_i128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .src0x, .tmp0x, ._ },
                                .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .dst_constraints = .{ .{ .int = .dword }, .any },
                            .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                                .{ ._, .v_ps, mir_tag, .dst0x, .src0x, .tmp0x, ._ },
                                .{ ._, .v_ps, .movhl, .tmp0x, .dst0x, .dst0x, ._ },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                                .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx2, null, null, null },
                            .dst_constraints = .{ .{ .int = .dword }, .any },
                            .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{
                                    .ref = .src0,
                                    .invert = switch (mir_tag) {
                                        else => unreachable,
                                        .@"and" => true,
                                        .@"or", .xor => false,
                                    },
                                } } },
                                .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                .{ ._, .vp_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .dst0y, .src0y, .lea(.tmp0y), ._ },
                                .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .dst_constraints = .{ .{ .int = .dword }, .any },
                            .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{
                                    .ref = .src0,
                                    .invert = switch (mir_tag) {
                                        else => unreachable,
                                        .@"and" => true,
                                        .@"or", .xor => false,
                                    },
                                } } },
                                .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                .{ ._, .v_ps, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .dst0y, .src0y, .lea(.tmp0y), ._ },
                                .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .v_ps, .movhl, .tmp2x, .dst0x, .dst0x, ._ },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b01) },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx512f, null, null, null },
                            .dst_constraints = .{ .{ .int = .dword }, .any },
                            .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .zword, .is = .dword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
                                .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .memd(.src0y, 32), ._ },
                                .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                                .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx512f, null, null, null },
                            .dst_constraints = .{ .{ .int = .dword }, .any },
                            .src_constraints = .{ .{ .scalar_int = .{ .of = .zword, .is = .dword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{
                                    .ref = .src0,
                                    .invert = switch (mir_tag) {
                                        else => unreachable,
                                        .@"and" => true,
                                        .@"or", .xor => false,
                                    },
                                } } },
                                .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
                                .{ ._, .v_dqa, .mov, .tmp2y, .memd(.src0y, 32), ._, ._ },
                                .{ ._, .vp_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .dst0y, .dst0y, .lea(.tmp0y), ._ },
                                .{ ._, .vp_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .tmp2y, .tmp2y, .lead(.tmp0y, 32), ._ },
                                .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .tmp2y, ._ },
                                .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx2, null, null, null },
                            .dst_constraints = .{ .{ .int = .dword }, .any },
                            .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                                .{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                                .{ .@"0:", .vp_, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                                .{ ._, .v_i128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
                                .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .dst_constraints = .{ .{ .int = .dword }, .any },
                            .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                                .{ ._, .v_ps, .mova, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                                .{ .@"0:", .v_ps, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                                .{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
                                .{ ._, .v_ps, .movhl, .tmp1x, .dst0x, .dst0x, ._ },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
                                .{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b01) },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse2, null, null, null },
                            .dst_constraints = .{ .{ .int = .dword }, .any },
                            .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                                .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                                .{ .@"0:", .p_, mir_tag, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                                .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp1x, ._, ._ },
                                .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp1x, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx512f, null, null, null },
                            .dst_constraints = .{ .{ .int = .dword }, .any },
                            .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .zword, .is = .dword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{
                                    .ref = .src0,
                                    .invert = switch (mir_tag) {
                                        else => unreachable,
                                        .@"and" => true,
                                        .@"or", .xor => false,
                                    },
                                } } },
                                .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                                .{ ._, .v_dqa, .mov, .tmp2y, .lead(.tmp0y, 32), ._, ._ },
                                .{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ },
                                .{ ._, .vp_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .tmp2y, .tmp2y, .memad(.src0y, .add_size, -32), ._ },
                                .{ ._, .vp_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                                .{ .@"0:", .vp_, mir_tag, .tmp2y, .tmp2y, .memid(.src0y, .tmp0, 32), ._ },
                                .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                                .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .tmp2y, ._ },
                                .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx2, null, null, null },
                            .dst_constraints = .{ .{ .int = .dword }, .any },
                            .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{
                                    .ref = .src0,
                                    .invert = switch (mir_tag) {
                                        else => unreachable,
                                        .@"and" => true,
                                        .@"or", .xor => false,
                                    },
                                } } },
                                .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                                .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
                                .{ ._, .vp_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                                .{ .@"0:", .vp_, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                                .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .dst_constraints = .{ .{ .int = .dword }, .any },
                            .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{
                                    .ref = .src0,
                                    .invert = switch (mir_tag) {
                                        else => unreachable,
                                        .@"and" => true,
                                        .@"or", .xor => false,
                                    },
                                } } },
                                .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                                .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
                                .{ ._, .v_ps, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                                .{ .@"0:", .v_ps, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                                .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .v_ps, .movhl, .tmp2x, .dst0x, .dst0x, ._ },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b01) },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse2, null, null, null },
                            .dst_constraints = .{ .{ .int = .dword }, .any },
                            .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{
                                    .ref = .src0,
                                    .invert = switch (mir_tag) {
                                        else => unreachable,
                                        .@"and" => true,
                                        .@"or", .xor => false,
                                    },
                                } } },
                                .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ },
                                .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                                .{ ._, .p_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                                .{ .@"0:", .p_, mir_tag, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                                .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ },
                                .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ },
                            } },
                        }, .{
                            .dst_constraints = .{ .{ .int = .dword }, .any },
                            .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                                .{ ._, ._, .mov, .dst0d, .memad(.src0d, .add_unaligned_size, -4), ._, ._ },
                                .{ .@"0:", ._, mir_tag, .dst0d, .memi(.src0d, .tmp0), ._, ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .dst_constraints = .{ .{ .int = .qword }, .any },
                            .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .src0x, .tmp0x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse2, null, null, null },
                            .dst_constraints = .{ .{ .int = .qword }, .any },
                            .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mut_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .ref = .src0 }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx2, null, null, null },
                            .dst_constraints = .{ .{ .int = .qword }, .any },
                            .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .v_i128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .src0x, .tmp0x, ._ },
                                .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .dst_constraints = .{ .{ .int = .qword }, .any },
                            .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                                .{ ._, .v_ps, mir_tag, .dst0x, .src0x, .tmp0x, ._ },
                                .{ ._, .v_ps, .movhl, .tmp0x, .dst0x, .dst0x, ._ },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx2, null, null, null },
                            .dst_constraints = .{ .{ .int = .qword }, .any },
                            .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .v_i128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                                .{ ._, .vp_, mir_tag, .tmp0x, .src0x, .tmp0x, ._ },
                                .{ ._, .vp_d, .shuf, .dst0x, .src0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .tmp0x, .dst0x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .dst_constraints = .{ .{ .int = .qword }, .any },
                            .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                                .{ ._, .v_ps, mir_tag, .tmp0x, .src0x, .tmp0x, ._ },
                                .{ ._, .v_ps, .movhl, .dst0x, .src0x, .src0x, ._ },
                                .{ ._, .v_ps, mir_tag, .dst0x, .tmp0x, .dst0x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx512f, null, null, null },
                            .dst_constraints = .{ .{ .int = .qword }, .any },
                            .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .zword, .is = .qword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
                                .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .memd(.src0y, 32), ._ },
                                .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                                .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx512f, null, null, null },
                            .dst_constraints = .{ .{ .int = .qword }, .any },
                            .src_constraints = .{ .{ .scalar_int = .{ .of = .zword, .is = .qword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{
                                    .ref = .src0,
                                    .invert = switch (mir_tag) {
                                        else => unreachable,
                                        .@"and" => true,
                                        .@"or", .xor => false,
                                    },
                                } } },
                                .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
                                .{ ._, .v_dqa, .mov, .tmp2y, .memd(.src0y, 32), ._, ._ },
                                .{ ._, .vp_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .dst0y, .dst0y, .lea(.tmp0y), ._ },
                                .{ ._, .vp_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .tmp2y, .tmp2y, .lead(.tmp0y, 32), ._ },
                                .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .tmp2y, ._ },
                                .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx2, null, null, null },
                            .dst_constraints = .{ .{ .int = .qword }, .any },
                            .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                                .{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                                .{ .@"0:", .vp_, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                                .{ ._, .v_i128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
                                .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .dst_constraints = .{ .{ .int = .qword }, .any },
                            .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                                .{ ._, .v_ps, .mova, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                                .{ .@"0:", .v_ps, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                                .{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
                                .{ ._, .v_ps, .movhl, .tmp1x, .dst0x, .dst0x, ._ },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse2, null, null, null },
                            .dst_constraints = .{ .{ .int = .qword }, .any },
                            .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                                .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                                .{ .@"0:", .p_, mir_tag, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                                .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp1x, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx512f, null, null, null },
                            .dst_constraints = .{ .{ .int = .qword }, .any },
                            .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .zword, .is = .qword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{
                                    .ref = .src0,
                                    .invert = switch (mir_tag) {
                                        else => unreachable,
                                        .@"and" => true,
                                        .@"or", .xor => false,
                                    },
                                } } },
                                .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                                .{ ._, .v_dqa, .mov, .tmp2y, .lead(.tmp0y, 32), ._, ._ },
                                .{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ },
                                .{ ._, .vp_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .tmp2y, .tmp2y, .memad(.src0y, .add_size, -32), ._ },
                                .{ ._, .vp_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                                .{ .@"0:", .vp_, mir_tag, .tmp2y, .tmp2y, .memid(.src0y, .tmp0, 32), ._ },
                                .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                                .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .tmp2y, ._ },
                                .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx2, null, null, null },
                            .dst_constraints = .{ .{ .int = .qword }, .any },
                            .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{
                                    .ref = .src0,
                                    .invert = switch (mir_tag) {
                                        else => unreachable,
                                        .@"and" => true,
                                        .@"or", .xor => false,
                                    },
                                } } },
                                .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                                .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
                                .{ ._, .vp_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                                .{ .@"0:", .vp_, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                                .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .dst_constraints = .{ .{ .int = .qword }, .any },
                            .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{
                                    .ref = .src0,
                                    .invert = switch (mir_tag) {
                                        else => unreachable,
                                        .@"and" => true,
                                        .@"or", .xor => false,
                                    },
                                } } },
                                .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                                .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
                                .{ ._, .v_ps, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                                .{ .@"0:", .v_ps, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                                .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                                .{ ._, .v_ps, .movhl, .tmp2x, .dst0x, .dst0x, ._ },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse2, null, null, null },
                            .dst_constraints = .{ .{ .int = .qword }, .any },
                            .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{
                                    .ref = .src0,
                                    .invert = switch (mir_tag) {
                                        else => unreachable,
                                        .@"and" => true,
                                        .@"or", .xor => false,
                                    },
                                } } },
                                .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ },
                                .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                                .{ ._, .p_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                                .{ .@"0:", .p_, mir_tag, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                                .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                                .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .@"64bit", null, null, null },
                            .dst_constraints = .{ .{ .int = .qword }, .any },
                            .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                                .{ ._, ._, .mov, .dst0q, .memad(.src0q, .add_unaligned_size, -8), ._, ._ },
                                .{ .@"0:", ._, mir_tag, .dst0q, .memi(.src0q, .tmp0), ._, ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx2, null, null, null },
                            .dst_constraints = .{ .{ .int = .xword }, .any },
                            .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .xword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_1_u128, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .v_i128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .src0x, .tmp0x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .dst_constraints = .{ .{ .int = .xword }, .any },
                            .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .xword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_sse, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_1_u128, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                                .{ ._, .v_ps, mir_tag, .dst0x, .src0x, .tmp0x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx512f, null, null, null },
                            .dst_constraints = .{ .{ .int = .xword }, .any },
                            .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .zword, .is = .xword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_1_u128, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
                                .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .memd(.src0y, 32), ._ },
                                .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx512f, null, null, null },
                            .dst_constraints = .{ .{ .int = .xword }, .any },
                            .src_constraints = .{ .{ .scalar_int = .{ .of = .zword, .is = .xword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .vector_2_u128, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .v_dqa, .mov, .tmp0y, .mem(.src0y), ._, ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .tmp0x, .memd(.src0x, 32), ._ },
                                .{ ._, .v_i128, .extract, .tmp0x, .tmp0y, .ui(1), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx2, null, null, null },
                            .dst_constraints = .{ .{ .int = .xword }, .any },
                            .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .yword, .is = .xword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_1_u128, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                                .{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                                .{ .@"0:", .vp_, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                                .{ ._, .v_i128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .dst_constraints = .{ .{ .int = .xword }, .any },
                            .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .yword, .is = .xword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_1_u128, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                                .{ ._, .v_ps, .mova, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                                .{ .@"0:", .v_ps, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                                .{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse2, null, null, null },
                            .dst_constraints = .{ .{ .int = .xword }, .any },
                            .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                                .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                                .{ .@"0:", .p_, mir_tag, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx512f, null, null, null },
                            .dst_constraints = .{ .{ .int = .xword }, .any },
                            .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .zword, .is = .xword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{
                                    .ref = .src0,
                                    .invert = switch (mir_tag) {
                                        else => unreachable,
                                        .@"and" => true,
                                        .@"or", .xor => false,
                                    },
                                } } },
                                .{ .type = .vector_2_u128, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                                .{ ._, .v_dqa, .mov, .tmp2y, .lead(.tmp0y, 32), ._, ._ },
                                .{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ },
                                .{ ._, .vp_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .tmp2y, .tmp2y, .memad(.src0y, .add_size, -32), ._ },
                                .{ ._, .vp_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                                .{ .@"0:", .vp_, mir_tag, .tmp2y, .tmp2y, .memid(.src0y, .tmp0, 32), ._ },
                                .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                                .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .tmp2y, ._ },
                                .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx2, null, null, null },
                            .dst_constraints = .{ .{ .int = .xword }, .any },
                            .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .xword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{
                                    .ref = .src0,
                                    .invert = switch (mir_tag) {
                                        else => unreachable,
                                        .@"and" => true,
                                        .@"or", .xor => false,
                                    },
                                } } },
                                .{ .type = .vector_1_u128, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                                .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
                                .{ ._, .vp_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                                .{ .@"0:", .vp_, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                                .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                                .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .dst_constraints = .{ .{ .int = .xword }, .any },
                            .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .xword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{
                                    .ref = .src0,
                                    .invert = switch (mir_tag) {
                                        else => unreachable,
                                        .@"and" => true,
                                        .@"or", .xor => false,
                                    },
                                } } },
                                .{ .type = .vector_1_u128, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                                .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
                                .{ ._, .v_ps, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                                .{ .@"0:", .v_ps, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                                .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                                .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
                            } },
                        }, .{
                            .required_features = .{ .sse2, null, null, null },
                            .dst_constraints = .{ .{ .int = .xword }, .any },
                            .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .xword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{
                                    .ref = .src0,
                                    .invert = switch (mir_tag) {
                                        else => unreachable,
                                        .@"and" => true,
                                        .@"or", .xor => false,
                                    },
                                } } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ },
                                .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                                .{ ._, .p_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                                .{ .@"0:", .p_, mir_tag, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx512f, null, null, null },
                            .dst_constraints = .{ .{ .int = .yword }, .any },
                            .src_constraints = .{ .{ .scalar_int = .{ .of = .zword, .is = .yword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .each = .{ .once = &.{
                                .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
                                .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .memd(.src0y, 32), ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx2, null, null, null },
                            .dst_constraints = .{ .{ .int = .yword }, .any },
                            .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .yword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                                .{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                                .{ .@"0:", .vp_, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .dst_constraints = .{ .{ .int = .yword }, .any },
                            .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .yword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                                .{ ._, .v_ps, .mova, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                                .{ .@"0:", .v_ps, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx512f, null, null, null },
                            .dst_constraints = .{ .{ .int = .yword }, .any },
                            .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .zword, .is = .yword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{
                                    .ref = .src0,
                                    .invert = switch (mir_tag) {
                                        else => unreachable,
                                        .@"and" => true,
                                        .@"or", .xor => false,
                                    },
                                } } },
                                .{ .type = .vector_1_u256, .kind = .{ .rc = .sse } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                                .{ ._, .v_dqa, .mov, .tmp2y, .lead(.tmp0y, 32), ._, ._ },
                                .{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ },
                                .{ ._, .vp_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .tmp2y, .tmp2y, .memad(.src0y, .add_size, -32), ._ },
                                .{ ._, .vp_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                                .{ .@"0:", .vp_, mir_tag, .tmp2y, .tmp2y, .memid(.src0y, .tmp0, 32), ._ },
                                .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                                .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .tmp2y, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx2, null, null, null },
                            .dst_constraints = .{ .{ .int = .yword }, .any },
                            .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .yword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{
                                    .ref = .src0,
                                    .invert = switch (mir_tag) {
                                        else => unreachable,
                                        .@"and" => true,
                                        .@"or", .xor => false,
                                    },
                                } } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                                .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
                                .{ ._, .vp_, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                                .{ .@"0:", .vp_, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .avx, null, null, null },
                            .dst_constraints = .{ .{ .int = .yword }, .any },
                            .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .yword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{
                                    .ref = .src0,
                                    .invert = switch (mir_tag) {
                                        else => unreachable,
                                        .@"and" => true,
                                        .@"or", .xor => false,
                                    },
                                } } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .{ .rc = .sse }, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                                .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                                .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
                                .{ ._, .v_ps, switch (mir_tag) {
                                    else => unreachable,
                                    .@"and" => .@"or",
                                    .@"or", .xor => .@"and",
                                }, .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                                .{ .@"0:", .v_ps, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                                .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            } },
                        }, .{
                            .required_features = .{ .@"64bit", null, null, null },
                            .dst_constraints = .{ .{ .remainder_int = .{ .of = .qword, .is = .qword } }, .any },
                            .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                            .patterns = &.{
                                .{ .src = .{ .to_mem, .none, .none } },
                            },
                            .extra_temps = .{
                                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                                .{ .type = .u32, .kind = .{ .reg = .rsi } },
                                .{ .type = .usize, .kind = .{ .reg = .rdi } },
                                .{ .type = .u64, .kind = .{ .reg = .rcx } },
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                                .unused,
                            },
                            .dst_temps = .{ .mem, .unused },
                            .clobbers = .{ .eflags = true },
                            .each = .{ .once = &.{
                                .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_unaligned_size_sub_2_elem_size), ._, ._ },
                                .{ ._, ._, .lea, .tmp1p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                                .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                                .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_size_div_8), ._, ._ },
                                .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                                .{ .@"0:", ._, .mov, .tmp1d, .sia(-8, .dst0, .add_size), ._, ._ },
                                .{ ._, ._, .lea, .tmp2q, .memi(.src0, .tmp0), ._, ._ },
                                .{ .@"1:", ._, .mov, .tmp3q, .leai(.tmp2q, .tmp1), ._, ._ },
                                .{ ._, ._, mir_tag, .memi(.dst0q, .tmp1), .tmp3q, ._, ._ },
                                .{ ._, ._, .sub, .tmp1d, .si(8), ._, ._ },
                                .{ ._, ._nb, .j, .@"1b", ._, ._, ._ },
                                .{ ._, ._, .sub, .tmp0d, .sa(.dst0, .add_size), ._, ._ },
                                .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            } },
                        } },
                    },
                    .Min => comptime &.{ .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .word, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .srl, .tmp0x, .src0x, .ui(8), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .src0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .word, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._dqa, .mov, .tmp0x, .src0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .mins, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .word, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._dqa, .mov, .tmp0x, .src0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp1x, .src0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .word, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .srl, .tmp0x, .src0x, .ui(8), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .src0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .word, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._dqa, .mov, .tmp0x, .src0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .minu, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .mins, .tmp0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .srl, .dst0x, .src0x, .ui(8), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .tmp0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .mins, .tmp0x, .src0x, ._, ._ },
                            .{ ._, .p_w, .srl, .dst0x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .mins, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .src0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"and", .tmp0x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp1x, .src0x, ._, ._ },
                            .{ ._, .p_, .@"or", .tmp0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .srl, .dst0x, .ui(8), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .minu, .tmp0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .srl, .dst0x, .src0x, .ui(8), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .tmp0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .minu, .tmp0x, .src0x, ._, ._ },
                            .{ ._, .p_w, .srl, .dst0x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .minu, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .mins, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp0x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .mins, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp1x, .src0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp0x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .minu, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp0x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .minu, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_i8, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smax } } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .vp_, .@"or", .dst0x, .dst0x, .lea(.tmp0x), ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .srl, .tmp3x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_i8, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smax } } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .mins, .dst0x, .tmp3x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .mins, .dst0x, .tmp3x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp3x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp3x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .mins, .dst0x, .tmp3x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_i8, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smax } } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b01), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp3x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp3x, .ui(8), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_, .@"or", .dst0x, .src0x, .lea(.tmp0x), ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .minu, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .minu, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp2x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .minu, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .mins, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .mins, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp0x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .mins, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp1x, .src0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp0x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .minu, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .minu, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp0x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .minu, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_i8, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smax } } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .vp_, .@"or", .dst0x, .dst0x, .lea(.tmp0x), ._ },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .srl, .tmp3x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_i8, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smax } } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .mins, .dst0x, .tmp3x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .mins, .dst0x, .tmp3x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .mins, .dst0x, .tmp3x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp3x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp3x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .mins, .dst0x, .tmp3x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_i8, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smax } } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b01), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp3x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp3x, .ui(8), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_, .@"or", .dst0x, .src0x, .lea(.tmp0x), ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .minu, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .minu, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .minu, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp2x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .minu, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .mins, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .mins, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .mins, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp0x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .mins, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp1x, .src0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp0x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .minu, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .minu, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .minu, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp0x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .minu, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_32_i8, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smax } } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .srl, .tmp3x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_32_i8, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smax } } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .srl, .tmp3x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_i128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_i128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .zword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_64_i8, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smax } } },
                            .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .mem(.src0y), ._ },
                            .{ ._, .vp_, .@"and", .tmp3y, .tmp3y, .memd(.src0y, 32), ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .vp_, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, .vp_b, .mins, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .srl, .tmp3x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .zword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp2y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .mem(.src0y), ._ },
                            .{ ._, .vp_, .@"or", .tmp2y, .tmp2y, .memd(.src0y, 32), ._ },
                            .{ ._, .vp_b, .minu, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .zword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .vp_b, .mins, .dst0y, .dst0y, .memd(.src0y, 32), ._ },
                            .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .zword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .vp_b, .minu, .dst0y, .dst0y, .memd(.src0y, 32), ._ },
                            .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                            .{ .@"0:", .vp_b, .mins, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .srl, .tmp1x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .vp_b, .mins, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .srl, .tmp1x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .p_b, .mins, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .mins, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .mins, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .mins, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp1x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .mins, .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp2x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b01), ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp2x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp1x, .ui(8), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                            .{ .@"0:", .vp_b, .minu, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .srl, .tmp1x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .vp_b, .minu, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .srl, .tmp1x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .p_b, .minu, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .minu, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .minu, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .minu, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp1x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .minu, .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .zword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_64_i8, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smax } } },
                            .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .vp_, .@"and", .tmp3y, .tmp3y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .vp_, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ },
                            .{ .@"0:", .vp_b, .mins, .tmp3y, .tmp3y, .memid(.src0y, .tmp0, 32), ._ },
                            .{ ._, .vp_b, .mins, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_b, .mins, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .srl, .tmp3x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_32_i8, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smax } } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
                            .{ .@"0:", .vp_b, .mins, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .srl, .tmp3x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_32_i8, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smax } } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ .@"0:", .vp_b, .mins, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .srl, .tmp3x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_i8, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smax } } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ .@"0:", .p_b, .mins, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .mins, .dst0x, .tmp3x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .mins, .dst0x, .tmp3x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .mins, .dst0x, .tmp3x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp3x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp3x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .mins, .dst0x, .tmp3x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_i8, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smax } } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp3x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b01), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp3x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp3x, .ui(8), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .zword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp2y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ },
                            .{ ._, .vp_, .@"or", .tmp2y, .tmp2y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                            .{ .@"0:", .vp_b, .minu, .tmp2y, .tmp2y, .memid(.src0y, .tmp0, 32), ._ },
                            .{ ._, .vp_b, .minu, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_b, .minu, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ .@"0:", .vp_b, .minu, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ .@"0:", .vp_b, .minu, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ .@"0:", .p_b, .minu, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .minu, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .minu, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .minu, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp2x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .minu, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .cmov, .slow_incdec, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .movsx, .dst0d, .memad(.src0b, .add_unaligned_size, -1), ._, ._ },
                            .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0b, .tmp1b, ._, ._ },
                            .{ ._, ._nl, .cmov, .dst0d, .tmp1d, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .cmov, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .movsx, .dst0d, .memad(.src0b, .add_unaligned_size, -1), ._, ._ },
                            .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0b, .tmp1b, ._, ._ },
                            .{ ._, ._nl, .cmov, .dst0d, .tmp1d, ._, ._ },
                            .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                            .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .slow_incdec, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .movsx, .dst0d, .memad(.src0b, .add_unaligned_size, -1), ._, ._ },
                            .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0b, .tmp1b, ._, ._ },
                            .{ ._, ._l, .j, .@"1f", ._, ._, ._ },
                            .{ ._, ._, .mov, .dst0d, .tmp1d, ._, ._ },
                            .{ .@"1:", ._, .sub, .tmp0d, .si(1), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .movsx, .dst0d, .memad(.src0b, .add_unaligned_size, -1), ._, ._ },
                            .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0b, .tmp1b, ._, ._ },
                            .{ ._, ._l, .j, .@"1f", ._, ._, ._ },
                            .{ ._, ._, .mov, .dst0d, .tmp1d, ._, ._ },
                            .{ .@"1:", ._c, .de, .tmp0d, ._, ._, ._ },
                            .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .cmov, .slow_incdec, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .movzx, .dst0d, .memad(.src0b, .add_unaligned_size, -1), ._, ._ },
                            .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0b, .tmp1b, ._, ._ },
                            .{ ._, ._nb, .cmov, .dst0d, .tmp1d, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .cmov, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .movzx, .dst0d, .memad(.src0b, .add_unaligned_size, -1), ._, ._ },
                            .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0b, .tmp1b, ._, ._ },
                            .{ ._, ._nb, .cmov, .dst0d, .tmp1d, ._, ._ },
                            .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                            .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .slow_incdec, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .movzx, .dst0d, .memad(.src0b, .add_unaligned_size, -1), ._, ._ },
                            .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0b, .tmp1b, ._, ._ },
                            .{ ._, ._b, .j, .@"1f", ._, ._, ._ },
                            .{ ._, ._, .mov, .dst0d, .tmp1d, ._, ._ },
                            .{ .@"1:", ._, .sub, .tmp0d, .si(1), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .movzx, .dst0d, .memad(.src0b, .add_unaligned_size, -1), ._, ._ },
                            .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0b, .tmp1b, ._, ._ },
                            .{ ._, ._b, .j, .@"1f", ._, ._, ._ },
                            .{ ._, ._, .mov, .dst0d, .tmp1d, ._, ._ },
                            .{ .@"1:", ._c, .de, .tmp0d, ._, ._, ._ },
                            .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .dword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .mins, .dst0x, .src0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .dword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .mins, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .dword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .minu, .dst0x, .src0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .dword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .minu, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .dword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .src0x, ._, ._ },
                            .{ ._, .p_w, .subus, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .sub, .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .mins, .tmp0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .dst0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mins, .dst0x, .tmp0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .mins, .tmp0x, .src0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .dst0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .mins, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .minu, .tmp0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .dst0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .minu, .dst0x, .tmp0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .minu, .tmp0x, .src0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .dst0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .minu, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .subus, .tmp1x, .src0x, ._, ._ },
                            .{ ._, .p_w, .sub, .tmp0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .dst0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .subus, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .sub, .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mins, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .mins, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .mins, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .mins, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .minu, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .minu, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .minu, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .minu, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .src0x, ._, ._ },
                            .{ ._, .p_w, .subus, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .sub, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .subus, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .sub, .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_w, .broadcast, .tmp2x, .lea(.tmp0w), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .tmp2x, .src0x, ._ },
                            .{ ._, .vp_, .@"or", .dst0x, .dst0x, .lea(.tmp0x), ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ss, .broadcast, .tmp2x, .lea(.tmp0d), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .tmp2x, .src0x, ._ },
                            .{ ._, .vp_, .@"or", .dst0x, .dst0x, .lea(.tmp0x), ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._, .movddup, .tmp3x, .lea(.tmp0q), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, .ph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp3x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smax } } },
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .mins, .dst0x, .tmp3x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .mins, .dst0x, .tmp3x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .mins, .dst0x, .tmp3x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_, .@"or", .dst0x, .src0x, .lea(.tmp0x), ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, .ph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp3x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .subus, .tmp3x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .sub, .dst0x, .tmp3x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp3x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .subus, .tmp3x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .sub, .dst0x, .tmp3x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, ._dqa, .mov, .tmp3x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .subus, .tmp3x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .sub, .dst0x, .tmp3x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_w, .broadcast, .tmp2x, .lea(.tmp0w), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .src0x, .tmp2x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ss, .broadcast, .tmp2x, .lea(.tmp0d), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .src0x, .tmp2x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .ph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .mins, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .mins, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .mins, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vph_w, .minposu, .dst0x, .src0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .ph_w, .minposu, .dst0x, .src0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .src0x, ._, ._ },
                            .{ ._, .p_w, .subus, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .sub, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .subus, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .sub, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .subus, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .sub, .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_w, .broadcast, .tmp2y, .lea(.tmp0w), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0y, .tmp2y, .src0y, ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_i128, .extract, .tmp4x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .minu, .dst0x, .dst0x, .tmp4x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ss, .broadcast, .tmp2y, .lea(.tmp0d), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                            .{ ._, .v_ps, .xor, .dst0y, .tmp2y, .src0y, ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_f128, .extract, .tmp4x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .minu, .dst0x, .dst0x, .tmp4x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_i128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_w, .mins, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ },
                            .{ ._, .vp_w, .broadcast, .tmp0x, .lea(.tmp1w), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_w, .mins, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ss, .broadcast, .tmp0x, .lea(.tmp1d), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_i128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_w, .minu, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_w, .minu, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .zword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_w, .broadcast, .tmp2y, .lea(.tmp0w), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0y, .tmp2y, .mem(.src0y), ._ },
                            .{ ._, .vp_, .xor, .tmp4y, .tmp2y, .memd(.src0y, 32), ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .vp_, .@"or", .tmp4y, .tmp4y, .lead(.tmp0y, 32), ._ },
                            .{ ._, .vp_w, .minu, .dst0y, .dst0y, .tmp4y, ._ },
                            .{ ._, .v_i128, .extract, .tmp4x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .minu, .dst0x, .dst0x, .tmp4x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp4x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .zword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp2y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .mem(.src0y), ._ },
                            .{ ._, .vp_, .@"or", .tmp2y, .tmp2y, .memd(.src0y, 32), ._ },
                            .{ ._, .vp_w, .minu, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .zword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .vp_w, .mins, .dst0y, .dst0y, .memd(.src0y, 32), ._ },
                            .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .mins, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ },
                            .{ ._, .vp_w, .broadcast, .tmp0x, .lea(.tmp1w), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .zword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .vp_w, .minu, .dst0y, .dst0y, .memd(.src0y, 32), ._ },
                            .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .minu, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_signed_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .{ .type = .i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                            .{ .@"0:", .vp_w, .mins, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .mins, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .vp_w, .broadcast, .tmp1x, .lea(.tmp0w), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .vp_w, .mins, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ss, .broadcast, .tmp2x, .lea(.tmp0d), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .p_w, .mins, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .ph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .p_w, .mins, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .mins, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .mins, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .mins, .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_unsigned_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                            .{ .@"0:", .vp_w, .minu, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .minu, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .vp_w, .minu, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .p_w, .minu, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .ph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .subus, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .p_w, .sub, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .subus, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .sub, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .subus, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .sub, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b01), ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .subus, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .sub, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .zword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_32_i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smax } } },
                            .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } },
                            .{ .type = .i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .vp_, .@"and", .tmp3y, .tmp3y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .vp_, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ },
                            .{ .@"0:", .vp_w, .mins, .tmp3y, .tmp3y, .memid(.src0y, .tmp0, 32), ._ },
                            .{ ._, .vp_w, .mins, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_w, .mins, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp4), ._, ._ },
                            .{ ._, .vp_w, .broadcast, .tmp3x, .lea(.tmp0w), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smax } } },
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .{ .type = .i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
                            .{ .@"0:", .vp_w, .mins, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp4), ._, ._ },
                            .{ ._, .vp_w, .broadcast, .tmp3x, .lea(.tmp0w), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smax } } },
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ .@"0:", .vp_w, .mins, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp4), ._, ._ },
                            .{ ._, .v_ss, .broadcast, .tmp3x, .lea(.tmp0d), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smax } } },
                            .{ .type = .vector_4_i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ .@"0:", .p_w, .mins, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                            .{ ._, ._, .movddup, .tmp4x, .lea(.tmp0q), ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .ph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp4x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smax } } },
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ .@"0:", .p_w, .mins, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .mins, .dst0x, .tmp3x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .mins, .dst0x, .tmp3x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .mins, .dst0x, .tmp3x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .zword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp2y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ },
                            .{ ._, .vp_, .@"or", .tmp2y, .tmp2y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                            .{ .@"0:", .vp_w, .minu, .tmp2y, .tmp2y, .memid(.src0y, .tmp0, 32), ._ },
                            .{ ._, .vp_w, .minu, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_w, .minu, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ .@"0:", .vp_w, .minu, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ .@"0:", .vp_w, .minu, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ .@"0:", .p_w, .minu, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .ph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .subus, .tmp2x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .p_w, .sub, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp3x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .subus, .tmp3x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .sub, .dst0x, .tmp3x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp3x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .subus, .tmp3x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .sub, .dst0x, .tmp3x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, ._dqa, .mov, .tmp3x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .subus, .tmp3x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .sub, .dst0x, .tmp3x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .cmov, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .movsx, .dst0d, .memad(.src0w, .add_unaligned_size, -2), ._, ._ },
                            .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0d, .tmp1d, ._, ._ },
                            .{ ._, ._nl, .cmov, .dst0d, .tmp1d, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .movsx, .dst0d, .memad(.src0w, .add_unaligned_size, -2), ._, ._ },
                            .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0d, .tmp1d, ._, ._ },
                            .{ ._, ._l, .j, .@"1f", ._, ._, ._ },
                            .{ ._, ._, .mov, .dst0d, .tmp1d, ._, ._ },
                            .{ .@"1:", ._, .sub, .tmp0d, .si(2), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .cmov, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .movzx, .dst0d, .memad(.src0w, .add_unaligned_size, -2), ._, ._ },
                            .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0d, .tmp1d, ._, ._ },
                            .{ ._, ._nb, .cmov, .dst0d, .tmp1d, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .movzx, .dst0d, .memad(.src0w, .add_unaligned_size, -2), ._, ._ },
                            .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0d, .tmp1d, ._, ._ },
                            .{ ._, ._b, .j, .@"1f", ._, ._, ._ },
                            .{ ._, ._, .mov, .dst0d, .tmp1d, ._, ._ },
                            .{ .@"1:", ._, .sub, .tmp0d, .si(2), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .mins, .dst0x, .src0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .mins, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp1x, .src0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .minu, .dst0x, .src0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .minu, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse3, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_i32, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_i32, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .mins, .tmp0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .dst0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .mins, .dst0x, .tmp0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .mins, .tmp0x, .src0x, ._, ._ },
                            .{ ._, .p_d, .shuf, .dst0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .mins, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .src0x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"and", .tmp0x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp1x, .src0x, ._, ._ },
                            .{ ._, .p_, .@"or", .tmp0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .dst0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .minu, .tmp0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .dst0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .minu, .dst0x, .tmp0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .minu, .tmp0x, .src0x, ._, ._ },
                            .{ ._, .p_d, .shuf, .dst0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .minu, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse3, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_i32, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"and", .tmp3x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"or", .tmp3x, .tmp4x, ._, ._ },
                            .{ ._, .p_w, .shufl, .dst0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_i32, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"and", .tmp3x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"or", .tmp3x, .tmp4x, ._, ._ },
                            .{ ._, .p_w, .shufl, .dst0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .mins, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .mins, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .mins, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .mins, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp1x, .src0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .minu, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .minu, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .minu, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .minu, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse3, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_i32, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp3x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp4x, .src0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_i32, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp3x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp4x, .src0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_i32, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smax } } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_i32, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smax } } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_i128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_d, .mins, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .mins, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .mins, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_d, .mins, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .mins, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .mins, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_i128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_d, .minu, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .minu, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .minu, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_d, .minu, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .minu, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .minu, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .zword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_i32, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smax } } },
                            .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .mem(.src0y), ._ },
                            .{ ._, .vp_, .@"and", .tmp3y, .tmp3y, .memd(.src0y, 32), ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .vp_, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, .vp_d, .mins, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .zword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp2y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .mem(.src0y), ._ },
                            .{ ._, .vp_, .@"or", .tmp2y, .tmp2y, .memd(.src0y, 32), ._ },
                            .{ ._, .vp_d, .minu, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .zword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .vp_d, .mins, .dst0y, .dst0y, .memd(.src0y, 32), ._ },
                            .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .mins, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .mins, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .mins, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .zword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .vp_d, .minu, .dst0y, .dst0y, .memd(.src0y, 32), ._ },
                            .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .minu, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .minu, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .minu, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                            .{ .@"0:", .vp_d, .mins, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .mins, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .mins, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .mins, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .vp_d, .mins, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .mins, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .mins, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .p_d, .mins, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .mins, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .mins, .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp2x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                            .{ .@"0:", .vp_d, .minu, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .minu, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .minu, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .minu, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .vp_d, .minu, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .minu, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .minu, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .p_d, .minu, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .minu, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .minu, .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse3, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_i32, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp3x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .p_, .xor, .tmp3x, .tmp2x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_i32, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp3x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .p_, .xor, .tmp3x, .tmp2x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .zword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_i32, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smax } } },
                            .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .vp_, .@"and", .tmp3y, .tmp3y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .vp_, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ },
                            .{ .@"0:", .vp_d, .mins, .tmp3y, .tmp3y, .memid(.src0y, .tmp0, 32), ._ },
                            .{ ._, .vp_d, .mins, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .mins, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_i32, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smax } } },
                            .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
                            .{ .@"0:", .vp_d, .mins, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_i32, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smax } } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ .@"0:", .vp_d, .mins, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .mins, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_i32, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smax } } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ .@"0:", .p_d, .mins, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .mins, .dst0x, .tmp3x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .mins, .dst0x, .tmp3x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_i32, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smax } } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp3x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .zword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp2y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ },
                            .{ ._, .vp_, .@"or", .tmp2y, .tmp2y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                            .{ .@"0:", .vp_d, .minu, .tmp2y, .tmp2y, .memid(.src0y, .tmp0, 32), ._ },
                            .{ ._, .vp_d, .minu, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .minu, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ .@"0:", .vp_d, .minu, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ .@"0:", .vp_d, .minu, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .minu, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ .@"0:", .p_d, .minu, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .minu, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .minu, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse3, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_i32, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp4x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .p_, .xor, .tmp4x, .tmp2x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp5x, .tmp4x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp5x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp5x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp5x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp5x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp4x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp5x, .tmp4x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp5x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp5x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp5x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp5x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp4x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp5x, .tmp4x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp5x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp5x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp5x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp5x, ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_i32, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp4x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .p_, .xor, .tmp4x, .tmp2x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp5x, .tmp4x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp5x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp5x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp5x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp5x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp4x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp5x, .tmp4x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp5x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp5x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp5x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp5x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp4x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp5x, .tmp4x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp5x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp5x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp5x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp5x, ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .cmov, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .mov, .dst0d, .memad(.src0d, .add_unaligned_size, -4), ._, ._ },
                            .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0d, .tmp1d, ._, ._ },
                            .{ ._, ._nl, .cmov, .dst0d, .tmp1d, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .mov, .dst0d, .memad(.src0d, .add_unaligned_size, -4), ._, ._ },
                            .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0d, .tmp1d, ._, ._ },
                            .{ ._, ._l, .j, .@"1f", ._, ._, ._ },
                            .{ ._, ._, .mov, .dst0d, .tmp1d, ._, ._ },
                            .{ .@"1:", ._, .sub, .tmp0d, .si(4), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .cmov, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .mov, .dst0d, .memad(.src0d, .add_unaligned_size, -4), ._, ._ },
                            .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0d, .tmp1d, ._, ._ },
                            .{ ._, ._nb, .cmov, .dst0d, .tmp1d, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .mov, .dst0d, .memad(.src0d, .add_unaligned_size, -4), ._, ._ },
                            .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0d, .tmp1d, ._, ._ },
                            .{ ._, ._b, .j, .@"1f", ._, ._, ._ },
                            .{ ._, ._, .mov, .dst0d, .tmp1d, ._, ._ },
                            .{ .@"1:", ._, .sub, .tmp0d, .si(4), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp1x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .src0x, .tmp0x, .tmp1x },
                        } },
                    }, .{
                        .required_features = .{ .sse4_2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .src0x, ._, ._ },
                            .{ ._, .p_q, .cmpgt, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_b, .blendv, .dst0x, .tmp0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_q, .broadcast, .tmp2x, .lea(.tmp0q), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .tmp2x, .src0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .tmp2x, .src0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_q, .cmpgt, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_b, .blendv, .dst0x, .tmp3x, .tmp4x, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp1x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_b, .blendv, .tmp0x, .src0x, .tmp0x, .tmp1x },
                            .{ ._, .v_i128, .extract, .dst0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp1x, .tmp0x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .tmp0x, .dst0x, .tmp1x },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp1x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_b, .blendv, .tmp0x, .src0x, .tmp0x, .tmp1x },
                            .{ ._, .v_f128, .extract, .dst0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp1x, .tmp0x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .tmp0x, .dst0x, .tmp1x },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0y, .tmp2y, .src0y, ._ },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_b, .blendv, .tmp3x, .dst0x, .tmp3x, .tmp4x },
                            .{ ._, .v_i128, .extract, .dst0x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .tmp3x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .tmp3x, .dst0x, .tmp4x },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_sd, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ },
                            .{ ._, .v_pd, .xor, .dst0y, .tmp2y, .src0y, ._ },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_b, .blendv, .tmp3x, .dst0x, .tmp3x, .tmp4x },
                            .{ ._, .v_f128, .extract, .dst0x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .tmp3x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .tmp3x, .dst0x, .tmp4x },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_i128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp1x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .src0x, .tmp0x, .tmp1x },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp0x, .tmp1x },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp1x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .src0x, .tmp0x, .tmp1x },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp0x, .tmp1x },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0y, .tmp2y, .src0y, ._ },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_sd, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ },
                            .{ ._, .v_pd, .xor, .dst0y, .tmp2y, .src0y, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .zword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smax } } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .mem(.src0y), ._ },
                            .{ ._, .vp_, .@"and", .tmp3y, .tmp3y, .memd(.src0y, 32), ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .vp_, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4y, .dst0y, .tmp3y, ._ },
                            .{ ._, .vp_b, .blendv, .dst0y, .dst0y, .tmp3y, .tmp4y },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .zword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp4y, .memd(.src0y, 32), ._, ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .vp_, .@"or", .tmp4y, .tmp4y, .lead(.tmp0y, 32), ._ },
                            .{ ._, .vp_, .xor, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .vp_, .xor, .tmp4y, .tmp4y, .tmp2y, ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp5y, .dst0y, .tmp4y, ._ },
                            .{ ._, .vp_b, .blendv, .dst0y, .dst0y, .tmp4y, .tmp5y },
                            .{ ._, .v_i128, .extract, .tmp4x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp5x, .dst0x, .tmp4x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp4x, .tmp5x },
                            .{ ._, .vp_d, .shuf, .tmp4x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp5x, .dst0x, .tmp4x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp4x, .tmp5x },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .zword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp0y, .memd(.src0y, 32), ._, ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp1y, .dst0y, .tmp0y, ._ },
                            .{ ._, .vp_b, .blendv, .dst0y, .dst0y, .tmp0y, .tmp1y },
                            .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp0x, .tmp1x },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp0x, .tmp1x },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .zword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0y, .tmp2y, .mem(.src0y), ._ },
                            .{ ._, .vp_, .xor, .tmp3y, .tmp2y, .memd(.src0y, 32), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4y, .dst0y, .tmp3y, ._ },
                            .{ ._, .vp_b, .blendv, .dst0y, .dst0y, .tmp3y, .tmp4y },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                            .{ .@"0:", .v_dqa, .mov, .tmp1y, .memi(.src0y, .tmp0), ._, ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp2y, .dst0y, .tmp1y, ._ },
                            .{ ._, .vp_b, .blendv, .dst0y, .dst0y, .tmp1y, .tmp2y },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp2x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp1x, .tmp2x },
                            .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp2x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp1x, .tmp2x },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp2x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp1x, .tmp2x },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp2x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp1x, .tmp2x },
                        } },
                    }, .{
                        .required_features = .{ .sse4_2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, .p_q, .cmpgt, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, .p_b, .blendv, .dst0x, .tmp1x, .tmp2x, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, .p_q, .cmpgt, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, .p_b, .blendv, .dst0x, .tmp1x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0y, .tmp2y, .memad(.src0y, .add_unaligned_size, -32), ._ },
                            .{ .@"0:", .vp_, .xor, .tmp3y, .tmp2y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4y, .dst0y, .tmp3y, ._ },
                            .{ ._, .vp_b, .blendv, .dst0y, .dst0y, .tmp3y, .tmp4y },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .tmp2x, .memad(.src0x, .add_unaligned_size, -16), ._ },
                            .{ .@"0:", .vp_, .xor, .tmp3x, .tmp2x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp3x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .p_, .xor, .tmp3x, .tmp2x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_q, .cmpgt, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_b, .blendv, .dst0x, .tmp3x, .tmp4x, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_q, .cmpgt, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_b, .blendv, .dst0x, .tmp3x, .tmp4x, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .zword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smax } } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .vp_, .@"and", .tmp3y, .tmp3y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .vp_, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-96, .src0, .add_size), ._, ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4y, .dst0y, .tmp3y, ._ },
                            .{ ._, .vp_b, .blendv, .dst0y, .dst0y, .tmp3y, .tmp4y },
                            .{ .@"0:", .v_dqa, .mov, .tmp3y, .memi(.src0y, .tmp0), ._, ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4y, .dst0y, .tmp3y, ._ },
                            .{ ._, .vp_b, .blendv, .dst0y, .dst0y, .tmp3y, .tmp4y },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smax } } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
                            .{ .@"0:", .v_dqa, .mov, .tmp3y, .memi(.src0y, .tmp0), ._, ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4y, .dst0y, .tmp3y, ._ },
                            .{ ._, .vp_b, .blendv, .dst0y, .dst0y, .tmp3y, .tmp4y },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smax } } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                            .{ .@"0:", .v_dqa, .mov, .tmp3x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                        } },
                    }, .{
                        .required_features = .{ .sse4_2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_2_i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smax } } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp3x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_q, .cmpgt, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_b, .blendv, .dst0x, .tmp3x, .tmp4x, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_q, .cmpgt, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_b, .blendv, .dst0x, .tmp3x, .tmp4x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .zword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp4y, .memad(.src0y, .add_size, -32), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_size, -64), ._, ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .vp_, .@"or", .tmp4y, .tmp4y, .lead(.tmp0y, 32), ._ },
                            .{ ._, .vp_, .xor, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .vp_, .xor, .tmp4y, .tmp4y, .tmp2y, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-96, .src0, .add_size), ._, ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp5y, .dst0y, .tmp4y, ._ },
                            .{ ._, .vp_b, .blendv, .dst0y, .dst0y, .tmp4y, .tmp5y },
                            .{ .@"0:", .vp_, .xor, .tmp4y, .tmp2y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp5y, .dst0y, .tmp4y, ._ },
                            .{ ._, .vp_b, .blendv, .dst0y, .dst0y, .tmp4y, .tmp5y },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp4x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp5x, .dst0x, .tmp4x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp4x, .tmp5x },
                            .{ ._, .vp_d, .shuf, .tmp4x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp5x, .dst0x, .tmp4x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp4x, .tmp5x },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_size, -32), ._, ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .vp_, .xor, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
                            .{ .@"0:", .vp_, .xor, .tmp4y, .tmp2y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp5y, .dst0y, .tmp4y, ._ },
                            .{ ._, .vp_b, .blendv, .dst0y, .dst0y, .tmp4y, .tmp5y },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp4x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp5x, .dst0x, .tmp4x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp4x, .tmp5x },
                            .{ ._, .vp_d, .shuf, .tmp4x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp5x, .dst0x, .tmp4x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp4x, .tmp5x },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_sd, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .memad(.src0y, .add_size, -32), ._, ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_ps, .xor, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp4x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp5x, .dst0x, .tmp4x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp4x, .tmp5x },
                            .{ .@"0:", .vp_, .xor, .tmp4x, .tmp2x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp5x, .dst0x, .tmp4x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp4x, .tmp5x },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .shuf, .tmp4x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp5x, .dst0x, .tmp4x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp4x, .tmp5x },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp4x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .p_, .xor, .tmp4x, .tmp2x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp5x, .dst0x, ._, ._ },
                            .{ ._, .p_q, .cmpgt, .tmp5x, .tmp4x, ._, ._ },
                            .{ ._, .p_b, .blendv, .dst0x, .tmp4x, .tmp5x, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp4x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp5x, .dst0x, ._, ._ },
                            .{ ._, .p_q, .cmpgt, .tmp5x, .tmp4x, ._, ._ },
                            .{ ._, .p_b, .blendv, .dst0x, .tmp4x, .tmp5x, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .@"64bit", .cmov, null, null },
                        .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .mov, .dst0q, .memad(.src0q, .add_unaligned_size, -8), ._, ._ },
                            .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0q, .tmp1q, ._, ._ },
                            .{ ._, ._nl, .cmov, .dst0q, .tmp1q, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .@"64bit", null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .mov, .dst0q, .memad(.src0q, .add_unaligned_size, -8), ._, ._ },
                            .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0q, .tmp1q, ._, ._ },
                            .{ ._, ._l, .j, .@"1f", ._, ._, ._ },
                            .{ ._, ._, .mov, .dst0q, .tmp1q, ._, ._ },
                            .{ .@"1:", ._, .sub, .tmp0d, .si(8), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .@"64bit", .cmov, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .mov, .dst0q, .memad(.src0q, .add_unaligned_size, -8), ._, ._ },
                            .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0q, .tmp1q, ._, ._ },
                            .{ ._, ._nb, .cmov, .dst0q, .tmp1q, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .@"64bit", null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .mov, .dst0q, .memad(.src0q, .add_unaligned_size, -8), ._, ._ },
                            .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0q, .tmp1q, ._, ._ },
                            .{ ._, ._b, .j, .@"1f", ._, ._, ._ },
                            .{ ._, ._, .mov, .dst0q, .tmp1q, ._, ._ },
                            .{ .@"1:", ._, .sub, .tmp0d, .si(8), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .@"64bit", .cmov, null, null },
                        .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                        .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .reg = .rdi } },
                            .{ .type = .usize, .kind = .{ .reg = .rsi } },
                            .{ .type = .isize, .kind = .{ .reg = .rcx } },
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_unaligned_size_sub_2_elem_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                            .{ .@"0:", ._, .mov, .tmp2p, .sia(1, .dst0, .sub_size_div_8), ._, ._ },
                            .{ ._, ._, .lea, .tmp3p, .memi(.src0, .tmp0), ._, ._ },
                            .{ ._, ._c, .cl, ._, ._, ._, ._ },
                            .{ .@"1:", ._, .mov, .tmp4q, .leasiad(.tmp1q, .@"8", .tmp2, .add_src0_elem_size, -8), ._, ._ },
                            .{ ._, ._, .sbb, .tmp4q, .leasiad(.tmp3q, .@"8", .tmp2, .add_src0_elem_size, -8), ._, ._ },
                            .{ ._, ._c, .in, .tmp2p, ._, ._, ._ },
                            .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                            .{ ._, ._, .mov, .tmp4q, .leaad(.tmp1q, .add_src0_elem_size, -8), ._, ._ },
                            .{ ._, ._, .sbb, .tmp4q, .leaad(.tmp3q, .add_src0_elem_size, -8), ._, ._ },
                            .{ ._, ._nl, .cmov, .tmp1p, .tmp3p, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .sa(.dst0, .add_size), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                            .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_size_div_8), ._, ._ },
                            .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .@"64bit", null, null, null },
                        .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                        .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .reg = .rdi } },
                            .{ .type = .usize, .kind = .{ .reg = .rsi } },
                            .{ .type = .isize, .kind = .{ .reg = .rcx } },
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_unaligned_size_sub_2_elem_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                            .{ .@"0:", ._, .mov, .tmp2p, .sia(1, .dst0, .sub_size_div_8), ._, ._ },
                            .{ ._, ._, .lea, .tmp3p, .memi(.src0, .tmp0), ._, ._ },
                            .{ ._, ._c, .cl, ._, ._, ._, ._ },
                            .{ .@"1:", ._, .mov, .tmp4q, .leasiad(.tmp1q, .@"8", .tmp2, .add_src0_elem_size, -8), ._, ._ },
                            .{ ._, ._, .sbb, .tmp4q, .leasiad(.tmp3q, .@"8", .tmp2, .add_src0_elem_size, -8), ._, ._ },
                            .{ ._, ._c, .in, .tmp2p, ._, ._, ._ },
                            .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                            .{ ._, ._, .mov, .tmp4q, .leaad(.tmp1q, .add_src0_elem_size, -8), ._, ._ },
                            .{ ._, ._, .sbb, .tmp4q, .leaad(.tmp3q, .add_src0_elem_size, -8), ._, ._ },
                            .{ ._, ._l, .j, .@"1f", ._, ._, ._ },
                            .{ ._, ._, .mov, .tmp1p, .tmp3p, ._, ._ },
                            .{ .@"1:", ._, .sub, .tmp0d, .sa(.dst0, .add_size), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                            .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_size_div_8), ._, ._ },
                            .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .@"64bit", .cmov, null, null },
                        .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
                        .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .reg = .rdi } },
                            .{ .type = .usize, .kind = .{ .reg = .rsi } },
                            .{ .type = .isize, .kind = .{ .reg = .rcx } },
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_unaligned_size_sub_2_elem_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                            .{ .@"0:", ._, .mov, .tmp2p, .sa(.dst0, .sub_size_div_8), ._, ._ },
                            .{ ._, ._, .lea, .tmp3p, .memi(.src0, .tmp0), ._, ._ },
                            .{ ._, ._c, .cl, ._, ._, ._, ._ },
                            .{ .@"1:", ._, .mov, .tmp4q, .leasia(.tmp1q, .@"8", .tmp2, .add_src0_elem_size), ._, ._ },
                            .{ ._, ._, .sbb, .tmp4q, .leasia(.tmp3q, .@"8", .tmp2, .add_src0_elem_size), ._, ._ },
                            .{ ._, ._c, .in, .tmp2p, ._, ._, ._ },
                            .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                            .{ ._, ._nb, .cmov, .tmp1p, .tmp3p, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .sa(.dst0, .add_size), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                            .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_size_div_8), ._, ._ },
                            .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .@"64bit", null, null, null },
                        .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
                        .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .reg = .rdi } },
                            .{ .type = .usize, .kind = .{ .reg = .rsi } },
                            .{ .type = .isize, .kind = .{ .reg = .rcx } },
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_unaligned_size_sub_2_elem_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                            .{ .@"0:", ._, .mov, .tmp2p, .sa(.dst0, .sub_size_div_8), ._, ._ },
                            .{ ._, ._, .lea, .tmp3p, .memi(.src0, .tmp0), ._, ._ },
                            .{ ._, ._c, .cl, ._, ._, ._, ._ },
                            .{ .@"1:", ._, .mov, .tmp4q, .leasia(.tmp1q, .@"8", .tmp2, .add_src0_elem_size), ._, ._ },
                            .{ ._, ._, .sbb, .tmp4q, .leasia(.tmp3q, .@"8", .tmp2, .add_src0_elem_size), ._, ._ },
                            .{ ._, ._c, .in, .tmp2p, ._, ._, ._ },
                            .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                            .{ ._, ._b, .j, .@"1f", ._, ._, ._ },
                            .{ ._, ._, .mov, .tmp1p, .tmp3p, ._, ._ },
                            .{ .@"1:", ._, .sub, .tmp0d, .sa(.dst0, .add_size), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                            .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_size_div_8), ._, ._ },
                            .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .dword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ss, .min, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .min, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_f16, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = nan } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"or", .dst0x, .src0x, .lea(.tmp0x), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .min, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .min, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .min, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .min, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_f16, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = nan } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp3y, .tmp3x, ._, ._ },
                            .{ ._, .v_ps, .min, .tmp4y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3y, .tmp3y, .tmp3y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp4y, .tmp3y },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .min, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .min, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp0y, .tmp0x, ._, ._ },
                            .{ ._, .v_ps, .min, .tmp1y, .dst0y, .tmp0y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp0y, .tmp0y, .tmp0y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp1y, .tmp0y },
                            .{ ._, .v_f128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .min, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .min, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .zword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_32_f16, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = nan } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_ps, .mova, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"and", .tmp3y, .tmp3y, .memd(.src0y, 32), ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .mem(.src0y), ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_ps, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, .v_f128, .extract, .tmp4x, .tmp3y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp3y, .tmp3x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp4y, .tmp4x, ._, ._ },
                            .{ ._, .v_ps, .min, .tmp5y, .tmp3y, .tmp4y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp4y, .tmp4y, .tmp4y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .tmp3y, .tmp3y, .tmp5y, .tmp4y },
                            .{ ._, .v_f128, .extract, .tmp4x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp4y, .tmp4x, ._, ._ },
                            .{ ._, .v_ps, .min, .tmp5y, .dst0y, .tmp4y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp4y, .tmp4y, .tmp4y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp5y, .tmp4y },
                            .{ ._, .v_ps, .min, .tmp4y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3y, .tmp3y, .tmp3y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp4y, .tmp3y },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .min, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .min, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .zword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .mova, .tmp0y, .memd(.src0y, 32), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp1x, .tmp0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp0y, .tmp0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp1y, .tmp1x, ._, ._ },
                            .{ ._, .v_ps, .min, .tmp2y, .tmp0y, .tmp1y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp1y, .tmp1y, .tmp1y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .tmp0y, .tmp0y, .tmp2y, .tmp1y },
                            .{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp1y, .tmp1x, ._, ._ },
                            .{ ._, .v_ps, .min, .tmp2y, .dst0y, .tmp1y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp1y, .tmp1y, .tmp1y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp2y, .tmp1y },
                            .{ ._, .v_ps, .min, .tmp1y, .dst0y, .tmp0y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp0y, .tmp0y, .tmp0y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp1y, .tmp0y },
                            .{ ._, .v_f128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .min, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .min, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_float = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .v_ps, .min, .tmp2y, .dst0y, .tmp1y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp1y, .tmp1y, .tmp1y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp2y, .tmp1y },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .min, .tmp2x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp1x, .tmp1x, .tmp1x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp2x, .tmp1x },
                            .{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .min, .tmp2x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp1x, .tmp1x, .tmp1x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp2x, .tmp1x },
                            .{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .tmp2x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp1x, .tmp1x, .tmp1x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp2x, .tmp1x },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .zword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_32_f16, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = nan } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_ps, .mova, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"and", .tmp3y, .tmp3y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_ps, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-80, .src0, .add_size), ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp4x, .tmp3y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp3y, .tmp3x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp4y, .tmp4x, ._, ._ },
                            .{ ._, .v_ps, .min, .tmp5y, .tmp3y, .tmp4y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp4y, .tmp4y, .tmp4y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .tmp3y, .tmp3y, .tmp5y, .tmp4y },
                            .{ ._, .v_f128, .extract, .tmp4x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp4y, .tmp4x, ._, ._ },
                            .{ ._, .v_ps, .min, .tmp5y, .dst0y, .tmp4y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp4y, .tmp4y, .tmp4y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp5y, .tmp4y },
                            .{ ._, .v_ps, .min, .tmp4y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3y, .tmp3y, .tmp3y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp4y, .tmp3y },
                            .{ .@"0:", .v_ps, .cvtph2, .tmp3y, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .v_ps, .min, .tmp4y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3y, .tmp3y, .tmp3y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp4y, .tmp3y },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .min, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .min, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_f16, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = nan } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp3y, .tmp3x, ._, ._ },
                            .{ ._, .v_ps, .min, .tmp4y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3y, .tmp3y, .tmp3y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp4y, .tmp3y },
                            .{ .@"0:", .v_ps, .cvtph2, .tmp3y, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .v_ps, .min, .tmp4y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3y, .tmp3y, .tmp3y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp4y, .tmp3y },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .min, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .min, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__fminh" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .vp_w, .insr, .dst0x, .dst0x, .memad(.src0w, .add_unaligned_size, -2), .ui(0) },
                            .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
                            .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__fminh" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, .p_, .xor, .dst0x, .dst0x, ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .p_w, .insr, .dst0x, .memad(.src0w, .add_unaligned_size, -2), .ui(0), ._ },
                            .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f16, .kind = .{ .reg = .ax } },
                            .{ .type = .f32, .kind = .mem },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__fminh" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .movzx, .tmp1d, .memad(.src0w, .add_unaligned_size, -2), ._, ._ },
                            .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                            .{ ._, ._ss, .mov, .dst0x, .mem(.tmp2d), ._, ._ },
                            .{ .@"0:", ._ps, .xor, .tmp3x, .tmp3x, ._, ._ },
                            .{ ._, ._ss, .mov, .tmp3x, .memi(.src0d, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .shuf, .tmp0x, .src0x, .src0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .tmp1x, .src0x, .tmp0x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .src0x, .tmp1x, .tmp0x },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .reg = .xmm0 } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .mova, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .tmp0x, .tmp0x, .ui(0b01), ._ },
                            .{ ._, ._ps, .mova, .tmp1x, .src0x, ._, ._ },
                            .{ ._, ._ss, .min, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, ._ss, .cmp, .tmp0x, .tmp0x, .sp(.ord), ._ },
                            .{ ._, ._ps, .blendv, .dst0x, .tmp1x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .mova, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .tmp0x, .tmp0x, .ui(0b01), ._ },
                            .{ ._, ._ps, .mova, .tmp1x, .src0x, ._, ._ },
                            .{ ._, ._ss, .min, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, ._ss, .cmp, .tmp0x, .tmp0x, .sp(.unord), ._ },
                            .{ ._, ._ps, .@"and", .dst0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .andn, .tmp0x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .@"or", .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .movhl, .tmp0x, .src0x, .src0x, ._ },
                            .{ ._, .v_ss, .min, .tmp1x, .src0x, .tmp0x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .tmp0x, .src0x, .tmp1x, .tmp0x },
                            .{ ._, .v_ps, .shuf, .dst0x, .src0x, .src0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .tmp1x, .tmp0x, .dst0x, ._ },
                            .{ ._, .v_ss, .cmp, .dst0x, .dst0x, .dst0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .tmp0x, .tmp1x, .dst0x },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .reg = .xmm0 } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .xor, .tmp0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._ps, .mova, .tmp1x, .src0x, ._, ._ },
                            .{ ._, ._ss, .min, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, ._ss, .cmp, .tmp0x, .tmp0x, .sp(.unord), ._ },
                            .{ ._, ._ps, .blendv, .tmp1x, .src0x, .tmp0x, ._ },
                            .{ ._, ._ps, .shuf, .dst0x, .src0x, .ui(0b01), ._ },
                            .{ ._, ._ps, .mova, .tmp0x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .mova, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, ._ss, .min, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, ._ss, .cmp, .tmp0x, .tmp0x, .sp(.ord), ._ },
                            .{ ._, ._ps, .blendv, .dst0x, .tmp1x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .xor, .tmp0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._ps, .mova, .tmp1x, .src0x, ._, ._ },
                            .{ ._, ._ss, .min, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, ._ss, .cmp, .tmp0x, .tmp0x, .sp(.ord), ._ },
                            .{ ._, ._ps, .@"and", .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .andn, .tmp0x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .@"or", .tmp0x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .shuf, .dst0x, .src0x, .ui(0b01), ._ },
                            .{ ._, ._ps, .mova, .tmp1x, .src0x, ._, ._ },
                            .{ ._, ._ss, .min, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, ._ss, .cmp, .tmp0x, .tmp0x, .sp(.unord), ._ },
                            .{ ._, ._ps, .@"and", .dst0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .andn, .tmp0x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .@"or", .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .movhl, .tmp0x, .src0x, .src0x, ._ },
                            .{ ._, .v_ps, .min, .tmp1x, .src0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .src0x, .tmp1x, .tmp0x },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .reg = .xmm0 } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .xor, .tmp0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._ps, .mova, .tmp1x, .src0x, ._, ._ },
                            .{ ._, ._ps, .min, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .cmp, .tmp0x, .tmp0x, .sp(.ord), ._ },
                            .{ ._, ._ps, .blendv, .dst0x, .tmp1x, .tmp0x, ._ },
                            .{ ._, ._ps, .mova, .tmp0x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .tmp0x, .tmp0x, .ui(0b01), ._ },
                            .{ ._, ._ps, .mova, .tmp1x, .src0x, ._, ._ },
                            .{ ._, ._ss, .min, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, ._ss, .cmp, .tmp0x, .tmp0x, .sp(.ord), ._ },
                            .{ ._, ._ps, .blendv, .dst0x, .tmp1x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .xor, .tmp0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._ps, .mova, .tmp1x, .src0x, ._, ._ },
                            .{ ._, ._ps, .min, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .cmp, .tmp0x, .tmp0x, .sp(.unord), ._ },
                            .{ ._, ._ps, .@"and", .dst0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .andn, .tmp0x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .@"or", .dst0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .mova, .tmp0x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .tmp0x, .tmp0x, .ui(0b01), ._ },
                            .{ ._, ._ps, .mova, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, ._ss, .min, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, ._ss, .cmp, .tmp0x, .tmp0x, .sp(.unord), ._ },
                            .{ ._, ._ps, .@"and", .dst0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .andn, .tmp0x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .@"or", .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_f32, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = nan } } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .min, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_ps, .movhl, .tmp3x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .min, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .v_ps, .min, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                            .{ ._, .v_ps, .movhl, .tmp0x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .min, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .zword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_f32, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = nan } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_ps, .mova, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .mem(.src0y), ._ },
                            .{ ._, .v_ps, .@"and", .tmp3y, .tmp3y, .memd(.src0y, 32), ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_ps, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, .v_ps, .min, .tmp4y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3y, .tmp3y, .tmp3y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp4y, .tmp3y },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .min, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_ps, .movhl, .tmp3x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .min, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .zword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .mova, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .v_ps, .mova, .tmp0y, .memd(.src0y, 32), ._, ._ },
                            .{ ._, .v_ps, .min, .tmp1y, .dst0y, .tmp0y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp0y, .tmp0y, .tmp0y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp1y, .tmp0y },
                            .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .min, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                            .{ ._, .v_ps, .movhl, .tmp0x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .min, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                            .{ .@"0:", .v_ps, .mova, .tmp1y, .memi(.src0y, .tmp0), ._, ._ },
                            .{ ._, .v_ps, .min, .tmp2y, .dst0y, .tmp1y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp1y, .tmp1y, .tmp1y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp2y, .tmp1y },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .min, .tmp2x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp1x, .tmp1x, .tmp1x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp2x, .tmp1x },
                            .{ ._, .v_ps, .movhl, .tmp1x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .min, .tmp2x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp1x, .tmp1x, .tmp1x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp2x, .tmp1x },
                            .{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .tmp2x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp1x, .tmp1x, .tmp1x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp2x, .tmp1x },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_f32, .kind = .{ .reg = .xmm0 } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._ps, .mova, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._ps, .mova, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .min, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .cmp, .tmp1x, .tmp1x, .sp(.ord), ._ },
                            .{ ._, ._ps, .blendv, .dst0x, .tmp2x, .tmp1x, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .mova, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .min, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .cmp, .tmp1x, .tmp1x, .sp(.ord), ._ },
                            .{ ._, ._ps, .blendv, .dst0x, .tmp2x, .tmp1x, ._ },
                            .{ ._, ._ps, .mova, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .tmp1x, .tmp1x, .ui(0b01), ._ },
                            .{ ._, ._ps, .mova, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, ._ss, .min, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, ._ss, .cmp, .tmp1x, .tmp1x, .sp(.ord), ._ },
                            .{ ._, ._ps, .blendv, .dst0x, .tmp2x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._ps, .mova, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._ps, .mova, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .min, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .cmp, .tmp1x, .tmp1x, .sp(.unord), ._ },
                            .{ ._, ._ps, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .andn, .tmp1x, .tmp2x, ._, ._ },
                            .{ ._, ._ps, .@"or", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .mova, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .min, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .cmp, .tmp1x, .tmp1x, .sp(.unord), ._ },
                            .{ ._, ._ps, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .andn, .tmp1x, .tmp2x, ._, ._ },
                            .{ ._, ._ps, .@"or", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .mova, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .tmp1x, .tmp1x, .ui(0b01), ._ },
                            .{ ._, ._ps, .mova, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, ._ss, .min, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, ._ss, .cmp, .tmp1x, .tmp1x, .sp(.unord), ._ },
                            .{ ._, ._ps, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .andn, .tmp1x, .tmp2x, ._, ._ },
                            .{ ._, ._ps, .@"or", .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .zword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_f32, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = nan } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_ps, .mova, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"and", .tmp3y, .tmp3y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_ps, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, .v_ps, .min, .tmp4y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3y, .tmp3y, .tmp3y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp4y, .tmp3y },
                            .{ ._, ._, .mov, .tmp0d, .sia(-96, .src0, .add_size), ._, ._ },
                            .{ .@"0:", .v_ps, .mova, .tmp3y, .memi(.src0y, .tmp0), ._, ._ },
                            .{ ._, .v_ps, .min, .tmp4y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3y, .tmp3y, .tmp3y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp4y, .tmp3y },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .min, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_ps, .movhl, .tmp3x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .min, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_f32, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = nan } } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .min, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ .@"0:", .v_ps, .mova, .tmp3x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .v_ps, .min, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_ps, .movhl, .tmp3x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .min, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_f32, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = nan } } },
                            .{ .type = .vector_4_f32, .kind = .{ .reg = .xmm0 } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._ps, .mova, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, ._ps, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, ._ps, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ .@"0:", ._ps, .mova, .tmp3x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._ps, .mova, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .min, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, ._ps, .cmp, .tmp3x, .tmp3x, .sp(.ord), ._ },
                            .{ ._, ._ps, .blendv, .dst0x, .tmp4x, .tmp3x, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._ps, .xor, .tmp3x, .tmp3x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp3x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .mova, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .min, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, ._ps, .cmp, .tmp3x, .tmp3x, .sp(.ord), ._ },
                            .{ ._, ._ps, .blendv, .dst0x, .tmp4x, .tmp3x, ._ },
                            .{ ._, ._ps, .mova, .tmp3x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .tmp3x, .tmp3x, .ui(0b01), ._ },
                            .{ ._, ._ps, .mova, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, ._ss, .min, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, ._ss, .cmp, .tmp3x, .tmp3x, .sp(.ord), ._ },
                            .{ ._, ._ps, .blendv, .dst0x, .tmp4x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_f32, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = nan } } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._ps, .mova, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, ._ps, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, ._ps, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ .@"0:", ._ps, .mova, .tmp3x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._ps, .mova, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .min, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, ._ps, .cmp, .tmp3x, .tmp3x, .sp(.unord), ._ },
                            .{ ._, ._ps, .@"and", .dst0x, .tmp3x, ._, ._ },
                            .{ ._, ._ps, .andn, .tmp3x, .tmp4x, ._, ._ },
                            .{ ._, ._ps, .@"or", .dst0x, .tmp3x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._ps, .xor, .tmp3x, .tmp3x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp3x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .mova, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .min, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, ._ps, .cmp, .tmp3x, .tmp3x, .sp(.unord), ._ },
                            .{ ._, ._ps, .@"and", .dst0x, .tmp3x, ._, ._ },
                            .{ ._, ._ps, .andn, .tmp3x, .tmp4x, ._, ._ },
                            .{ ._, ._ps, .@"or", .dst0x, .tmp3x, ._, ._ },
                            .{ ._, ._ps, .mova, .tmp3x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .tmp3x, .tmp3x, .ui(0b01), ._ },
                            .{ ._, ._ps, .mova, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, ._ss, .min, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, ._ss, .cmp, .tmp3x, .tmp3x, .sp(.unord), ._ },
                            .{ ._, ._ps, .@"and", .dst0x, .tmp3x, ._, ._ },
                            .{ ._, ._ps, .andn, .tmp3x, .tmp4x, ._, ._ },
                            .{ ._, ._ps, .@"or", .dst0x, .tmp3x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .movhl, .tmp0x, .src0x, .src0x, ._ },
                            .{ ._, .v_sd, .min, .tmp1x, .src0x, .tmp0x, ._ },
                            .{ ._, .v_sd, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0x, .src0x, .tmp1x, .tmp0x },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_f64, .kind = .{ .reg = .xmm0 } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .xor, .tmp0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._pd, .mova, .tmp1x, .src0x, ._, ._ },
                            .{ ._, ._sd, .min, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, ._sd, .cmp, .tmp0x, .tmp0x, .sp(.ord), ._ },
                            .{ ._, ._pd, .blendv, .dst0x, .tmp1x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .xor, .tmp0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._pd, .mova, .tmp1x, .src0x, ._, ._ },
                            .{ ._, ._sd, .min, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, ._sd, .cmp, .tmp0x, .tmp0x, .sp(.unord), ._ },
                            .{ ._, ._pd, .@"and", .dst0x, .tmp0x, ._, ._ },
                            .{ ._, ._pd, .andn, .tmp0x, .tmp1x, ._, ._ },
                            .{ ._, ._pd, .@"or", .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .v_sd, .min, .tmp1x, .src0x, .tmp0x, ._ },
                            .{ ._, .v_sd, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .tmp0x, .src0x, .tmp1x, .tmp0x },
                            .{ ._, .v_ps, .movhl, .dst0x, .src0x, .src0x, ._ },
                            .{ ._, .v_sd, .min, .tmp1x, .tmp0x, .dst0x, ._ },
                            .{ ._, .v_sd, .cmp, .dst0x, .dst0x, .dst0x, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0x, .tmp0x, .tmp1x, .dst0x },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .v_pd, .min, .tmp1x, .src0x, .tmp0x, ._ },
                            .{ ._, .v_pd, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0x, .src0x, .tmp1x, .tmp0x },
                            .{ ._, .v_ps, .movhl, .tmp0x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_sd, .min, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_sd, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .zword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_f64, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = nan } } },
                            .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_pd, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_pd, .mova, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_pd, .@"and", .dst0y, .dst0y, .mem(.src0y), ._ },
                            .{ ._, .v_pd, .@"and", .tmp3y, .tmp3y, .memd(.src0y, 32), ._ },
                            .{ ._, .v_pd, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_pd, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, .v_pd, .min, .tmp4y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_pd, .cmp, .tmp3y, .tmp3y, .tmp3y, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0y, .dst0y, .tmp4y, .tmp3y },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_pd, .min, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_pd, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_ps, .movhl, .tmp3x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_sd, .min, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_sd, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .zword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_pd, .mova, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .v_pd, .mova, .tmp0y, .memd(.src0y, 32), ._, ._ },
                            .{ ._, .v_pd, .min, .tmp1y, .dst0y, .tmp0y, ._ },
                            .{ ._, .v_pd, .cmp, .tmp0y, .tmp0y, .tmp0y, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0y, .dst0y, .tmp1y, .tmp0y },
                            .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_pd, .min, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_pd, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                            .{ ._, .v_ps, .movhl, .tmp0x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_sd, .min, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_sd, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_pd, .mova, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                            .{ .@"0:", .v_pd, .mova, .tmp1y, .memi(.src0y, .tmp0), ._, ._ },
                            .{ ._, .v_pd, .min, .tmp2y, .dst0y, .tmp1y, ._ },
                            .{ ._, .v_pd, .cmp, .tmp1y, .tmp1y, .tmp1y, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0y, .dst0y, .tmp2y, .tmp1y },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_pd, .min, .tmp2x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_pd, .cmp, .tmp1x, .tmp1x, .tmp1x, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .tmp2x, .tmp1x },
                            .{ ._, .v_pd, .cmp, .tmp1x, .tmp1x, .tmp1x, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .tmp2x, .tmp1x },
                            .{ ._, .v_ps, .movhl, .tmp1x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_sd, .min, .tmp2x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_sd, .cmp, .tmp1x, .tmp1x, .tmp1x, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .tmp2x, .tmp1x },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_f64, .kind = .{ .reg = .xmm0 } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._pd, .mova, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._pd, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._pd, .mova, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, ._pd, .min, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, ._pd, .cmp, .tmp1x, .tmp1x, .sp(.ord), ._ },
                            .{ ._, ._pd, .blendv, .dst0x, .tmp2x, .tmp1x, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, ._pd, .mova, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, ._sd, .min, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, ._sd, .cmp, .tmp1x, .tmp1x, .sp(.ord), ._ },
                            .{ ._, ._pd, .blendv, .dst0x, .tmp2x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._pd, .mova, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._pd, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._pd, .mova, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, ._pd, .min, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, ._pd, .cmp, .tmp1x, .tmp1x, .sp(.unord), ._ },
                            .{ ._, ._pd, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, ._pd, .andn, .tmp1x, .tmp2x, ._, ._ },
                            .{ ._, ._pd, .@"or", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._pd, .xor, .tmp1x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, ._pd, .mova, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, ._sd, .min, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, ._sd, .cmp, .tmp1x, .tmp1x, .sp(.unord), ._ },
                            .{ ._, ._pd, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, ._pd, .andn, .tmp1x, .tmp2x, ._, ._ },
                            .{ ._, ._pd, .@"or", .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .zword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_f64, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = nan } } },
                            .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_pd, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_pd, .mova, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_pd, .@"and", .tmp3y, .tmp3y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_pd, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                            .{ ._, .v_pd, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_pd, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, .v_pd, .min, .tmp4y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_pd, .cmp, .tmp3y, .tmp3y, .tmp3y, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0y, .dst0y, .tmp4y, .tmp3y },
                            .{ ._, ._, .mov, .tmp0d, .sia(-96, .src0, .add_size), ._, ._ },
                            .{ .@"0:", .v_pd, .mova, .tmp3y, .memi(.src0y, .tmp0), ._, ._ },
                            .{ ._, .v_pd, .min, .tmp4y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_pd, .cmp, .tmp3y, .tmp3y, .tmp3y, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0y, .dst0y, .tmp4y, .tmp3y },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_pd, .min, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_pd, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_ps, .movhl, .tmp3x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_sd, .min, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_sd, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_f64, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = nan } } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_pd, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_pd, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_pd, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_pd, .min, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_pd, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ .@"0:", .v_pd, .mova, .tmp3x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .v_pd, .min, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_pd, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_ps, .movhl, .tmp3x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_sd, .min, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_sd, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_2_f64, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = nan } } },
                            .{ .type = .vector_2_f64, .kind = .{ .reg = .xmm0 } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._pd, .mova, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, ._pd, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, ._pd, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ .@"0:", ._pd, .mova, .tmp3x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._pd, .mova, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, ._pd, .min, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, ._pd, .cmp, .tmp3x, .tmp3x, .sp(.ord), ._ },
                            .{ ._, ._pd, .blendv, .dst0x, .tmp4x, .tmp3x, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._ps, .xor, .tmp3x, .tmp3x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp3x, .dst0x, ._, ._ },
                            .{ ._, ._pd, .mova, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, ._sd, .min, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, ._sd, .cmp, .tmp3x, .tmp3x, .sp(.ord), ._ },
                            .{ ._, ._pd, .blendv, .dst0x, .tmp4x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_2_f64, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = nan } } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._pd, .mova, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, ._pd, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, ._pd, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ .@"0:", ._pd, .mova, .tmp3x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._pd, .mova, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, ._pd, .min, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, ._pd, .cmp, .tmp3x, .tmp3x, .sp(.unord), ._ },
                            .{ ._, ._pd, .@"and", .dst0x, .tmp3x, ._, ._ },
                            .{ ._, ._pd, .andn, .tmp3x, .tmp4x, ._, ._ },
                            .{ ._, ._pd, .@"or", .dst0x, .tmp3x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._ps, .xor, .tmp3x, .tmp3x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp3x, .dst0x, ._, ._ },
                            .{ ._, ._pd, .mova, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, ._sd, .min, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, ._sd, .cmp, .tmp3x, .tmp3x, .sp(.unord), ._ },
                            .{ ._, ._pd, .@"and", .dst0x, .tmp3x, ._, ._ },
                            .{ ._, ._pd, .andn, .tmp3x, .tmp4x, ._, ._ },
                            .{ ._, ._pd, .@"or", .dst0x, .tmp3x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .x87, .cmov, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f64, .kind = .{ .reg = .st7 } },
                            .{ .type = .f64, .kind = .{ .reg = .st6 } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .f_, .ld, .memad(.src0q, .add_unaligned_size, -8), ._, ._, ._ },
                            .{ .@"0:", .f_, .ld, .memi(.src0q, .tmp0), ._, ._, ._ },
                            .{ ._, .f_, .ucomi, .tmp2t, .tmp2t, ._, ._ },
                            .{ ._, .f_u, .cmov, .tmp2t, .tmp1t, ._, ._ },
                            .{ ._, .f_, .ucomi, .tmp2t, .tmp1t, ._, ._ },
                            .{ ._, .f_nb, .cmov, .tmp2t, .tmp1t, ._, ._ },
                            .{ ._, .f_p, .st, .tmp1t, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sahf, .x87, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f64, .kind = .{ .reg = .st7 } },
                            .{ .type = .f64, .kind = .{ .reg = .st6 } },
                            .{ .type = .u16, .kind = .{ .reg = .ax } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .f_, .ld, .memad(.src0q, .add_unaligned_size, -8), ._, ._, ._ },
                            .{ .@"0:", .f_, .ld, .memi(.src0q, .tmp0), ._, ._, ._ },
                            .{ ._, .f_, .ucom, .tmp1t, ._, ._, ._ },
                            .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ },
                            .{ ._, ._, .sahf, ._, ._, ._, ._ },
                            .{ ._, ._nb, .j, .@"1f", ._, ._, ._ },
                            .{ ._, .f_, .xam, ._, ._, ._, ._ },
                            .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ },
                            .{ ._, ._, .@"test", .tmp3h, .si(0b1_000_100), ._, ._ },
                            .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                            .{ ._, .f_, .xch, .tmp1t, ._, ._, ._ },
                            .{ .@"1:", .f_p, .st, .tmp2t, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .x87, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f64, .kind = .{ .reg = .st7 } },
                            .{ .type = .f64, .kind = .{ .reg = .st6 } },
                            .{ .type = .u16, .kind = .{ .reg = .ax } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .f_, .ld, .memad(.src0q, .add_unaligned_size, -8), ._, ._, ._ },
                            .{ .@"0:", .f_, .ld, .memi(.src0q, .tmp0), ._, ._, ._ },
                            .{ ._, .f_, .ucom, .tmp1t, ._, ._, ._ },
                            .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ },
                            .{ ._, ._, .@"test", .tmp3h, .si(0b0_000_001), ._, ._ },
                            .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                            .{ ._, .f_, .xam, ._, ._, ._, ._ },
                            .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ },
                            .{ ._, ._, .@"test", .tmp3h, .si(0b1_000_100), ._, ._ },
                            .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                            .{ ._, .f_, .xch, .tmp1t, ._, ._, ._ },
                            .{ .@"1:", .f_p, .st, .tmp2t, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .x87, .cmov, null, null },
                        .dst_constraints = .{ .{ .float = .tbyte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f80, .kind = .{ .reg = .st7 } },
                            .{ .type = .f80, .kind = .{ .reg = .st6 } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .x87 }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .f_, .ld, .memad(.src0t, .add_unaligned_size, -16), ._, ._, ._ },
                            .{ .@"0:", .f_, .ld, .memi(.src0t, .tmp0), ._, ._, ._ },
                            .{ ._, .f_, .ucomi, .tmp2t, .tmp2t, ._, ._ },
                            .{ ._, .f_u, .cmov, .tmp2t, .tmp1t, ._, ._ },
                            .{ ._, .f_, .ucomi, .tmp2t, .tmp1t, ._, ._ },
                            .{ ._, .f_nb, .cmov, .tmp2t, .tmp1t, ._, ._ },
                            .{ ._, .f_p, .st, .tmp1t, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sahf, .x87, null, null },
                        .dst_constraints = .{ .{ .float = .tbyte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f80, .kind = .{ .reg = .st7 } },
                            .{ .type = .f80, .kind = .{ .reg = .st6 } },
                            .{ .type = .u16, .kind = .{ .reg = .ax } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .x87 }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .f_, .ld, .memad(.src0t, .add_unaligned_size, -16), ._, ._, ._ },
                            .{ .@"0:", .f_, .ld, .memi(.src0t, .tmp0), ._, ._, ._ },
                            .{ ._, .f_, .ucom, .tmp1t, ._, ._, ._ },
                            .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ },
                            .{ ._, ._, .sahf, ._, ._, ._, ._ },
                            .{ ._, ._nb, .j, .@"1f", ._, ._, ._ },
                            .{ ._, .f_, .xam, ._, ._, ._, ._ },
                            .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ },
                            .{ ._, ._, .@"test", .tmp3h, .si(0b1_000_100), ._, ._ },
                            .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                            .{ ._, .f_, .xch, .tmp1t, ._, ._, ._ },
                            .{ .@"1:", .f_p, .st, .tmp2t, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .x87, null, null, null },
                        .dst_constraints = .{ .{ .float = .tbyte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f80, .kind = .{ .reg = .st7 } },
                            .{ .type = .f80, .kind = .{ .reg = .st6 } },
                            .{ .type = .u16, .kind = .{ .reg = .ax } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .x87 }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .f_, .ld, .memad(.src0t, .add_unaligned_size, -16), ._, ._, ._ },
                            .{ .@"0:", .f_, .ld, .memi(.src0t, .tmp0), ._, ._, ._ },
                            .{ ._, .f_, .ucom, .tmp1t, ._, ._, ._ },
                            .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ },
                            .{ ._, ._, .@"test", .tmp3h, .si(0b0_000_001), ._, ._ },
                            .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                            .{ ._, .f_, .xam, ._, ._, ._, ._ },
                            .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ },
                            .{ ._, ._, .@"test", .tmp3h, .si(0b1_000_100), ._, ._ },
                            .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                            .{ ._, .f_, .xch, .tmp1t, ._, ._, ._ },
                            .{ .@"1:", .f_p, .st, .tmp2t, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "fminq" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "fminq" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "fminq" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._ps, .mova, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "fminq" } },
                            .{ .type = .f128, .kind = .mem },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp2p, .memi(.src0, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.tmp4), ._, ._ },
                            .{ ._, .v_dqa, .mov, .lea(.tmp1x), .dst0x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "fminq" } },
                            .{ .type = .f128, .kind = .mem },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp2p, .memi(.src0, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.tmp4), ._, ._ },
                            .{ ._, ._dqa, .mov, .lea(.tmp1x), .dst0x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "fminq" } },
                            .{ .type = .f128, .kind = .mem },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp2p, .memi(.src0, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.tmp4), ._, ._ },
                            .{ ._, ._ps, .mova, .lea(.tmp1x), .dst0x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    } },
                    .Max => comptime &.{ .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .word, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .srl, .tmp0x, .src0x, .ui(8), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .src0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .word, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._dqa, .mov, .tmp0x, .src0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .maxs, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .word, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._dqa, .mov, .tmp0x, .src0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .src0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .word, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .srl, .tmp0x, .src0x, .ui(8), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .src0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .word, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._dqa, .mov, .tmp0x, .src0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .maxu, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .maxs, .tmp0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .srl, .dst0x, .src0x, .ui(8), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .tmp0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .maxs, .tmp0x, .src0x, ._, ._ },
                            .{ ._, .p_w, .srl, .dst0x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .maxs, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp1x, .src0x, ._, ._ },
                            .{ ._, .p_, .@"and", .tmp0x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp1x, .src0x, ._, ._ },
                            .{ ._, .p_, .@"or", .tmp0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .srl, .dst0x, .ui(8), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .maxu, .tmp0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .srl, .dst0x, .src0x, .ui(8), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .tmp0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .maxu, .tmp0x, .src0x, ._, ._ },
                            .{ ._, .p_w, .srl, .dst0x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .maxu, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .maxs, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp0x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .maxs, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .src0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp0x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .maxu, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp0x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .maxu, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_i8, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smin } } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .vp_, .@"or", .dst0x, .dst0x, .lea(.tmp0x), ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .srl, .tmp3x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_i8, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smin } } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .maxs, .dst0x, .tmp3x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .maxs, .dst0x, .tmp3x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp3x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp3x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .maxs, .dst0x, .tmp3x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_i8, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smin } } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b01), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp3x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp3x, .ui(8), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .maxu, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .maxu, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp2x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .maxu, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .maxs, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .maxs, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp0x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .maxs, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .src0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp0x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .maxu, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .maxu, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp0x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .maxu, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_i8, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smin } } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .vp_, .@"or", .dst0x, .dst0x, .lea(.tmp0x), ._ },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .srl, .tmp3x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_i8, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smin } } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .maxs, .dst0x, .tmp3x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .maxs, .dst0x, .tmp3x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .maxs, .dst0x, .tmp3x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp3x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp3x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .maxs, .dst0x, .tmp3x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_i8, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smin } } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b01), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp3x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp3x, .ui(8), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .maxu, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .maxu, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .maxu, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp2x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .maxu, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .maxs, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .maxs, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .maxs, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp0x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .maxs, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .src0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp0x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .maxu, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .maxu, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .maxu, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp0x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .maxu, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_32_i8, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smin } } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .srl, .tmp3x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_32_i8, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smin } } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .srl, .tmp3x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_i128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_i128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .zword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_64_i8, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smin } } },
                            .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .mem(.src0y), ._ },
                            .{ ._, .vp_, .@"and", .tmp3y, .tmp3y, .memd(.src0y, 32), ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .vp_, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, .vp_b, .maxs, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .srl, .tmp3x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .zword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp2y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .mem(.src0y), ._ },
                            .{ ._, .vp_, .@"and", .tmp2y, .tmp2y, .memd(.src0y, 32), ._ },
                            .{ ._, .vp_b, .maxu, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .zword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .vp_b, .maxs, .dst0y, .dst0y, .memd(.src0y, 32), ._ },
                            .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .zword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .vp_b, .maxu, .dst0y, .dst0y, .memd(.src0y, 32), ._ },
                            .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                            .{ .@"0:", .vp_b, .maxs, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .srl, .tmp1x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .vp_b, .maxs, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .srl, .tmp1x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .p_b, .maxs, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .maxs, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .maxs, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .maxs, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp1x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .maxs, .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp2x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b01), ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp2x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp1x, .ui(8), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                            .{ .@"0:", .vp_b, .maxu, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .srl, .tmp1x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .vp_b, .maxu, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .srl, .tmp1x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .p_b, .maxu, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .maxu, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .maxu, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .maxu, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp1x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .maxu, .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .zword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_64_i8, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smin } } },
                            .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .vp_, .@"and", .tmp3y, .tmp3y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .vp_, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ },
                            .{ .@"0:", .vp_b, .maxs, .tmp3y, .tmp3y, .memid(.src0y, .tmp0, 32), ._ },
                            .{ ._, .vp_b, .maxs, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_b, .maxs, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .srl, .tmp3x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_32_i8, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smin } } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
                            .{ .@"0:", .vp_b, .maxs, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .srl, .tmp3x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_32_i8, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smin } } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ .@"0:", .vp_b, .maxs, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .srl, .tmp3x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_i8, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smin } } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ .@"0:", .p_b, .maxs, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .maxs, .dst0x, .tmp3x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .maxs, .dst0x, .tmp3x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .maxs, .dst0x, .tmp3x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp3x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp3x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .maxs, .dst0x, .tmp3x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_i8, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smin } } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp3x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b01), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp3x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp3x, .ui(8), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_b, .cmpgt, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .zword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp2y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ },
                            .{ ._, .vp_, .@"and", .tmp2y, .tmp2y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                            .{ .@"0:", .vp_b, .maxu, .tmp2y, .tmp2y, .memid(.src0y, .tmp0, 32), ._ },
                            .{ ._, .vp_b, .maxu, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_b, .maxu, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ .@"0:", .vp_b, .maxu, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ .@"0:", .vp_b, .maxu, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ .@"0:", .p_b, .maxu, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .maxu, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .maxu, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .maxu, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp2x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .maxu, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .cmov, .slow_incdec, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .movsx, .dst0d, .memad(.src0b, .add_unaligned_size, -1), ._, ._ },
                            .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0b, .tmp1b, ._, ._ },
                            .{ ._, ._l, .cmov, .dst0d, .tmp1d, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .cmov, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .movsx, .dst0d, .memad(.src0b, .add_unaligned_size, -1), ._, ._ },
                            .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0b, .tmp1b, ._, ._ },
                            .{ ._, ._l, .cmov, .dst0d, .tmp1d, ._, ._ },
                            .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                            .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .slow_incdec, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .movsx, .dst0d, .memad(.src0b, .add_unaligned_size, -1), ._, ._ },
                            .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0b, .tmp1b, ._, ._ },
                            .{ ._, ._nl, .j, .@"1f", ._, ._, ._ },
                            .{ ._, ._, .mov, .dst0d, .tmp1d, ._, ._ },
                            .{ .@"1:", ._, .sub, .tmp0d, .si(1), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .dst_constraints = .{ .{ .signed_int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .movsx, .dst0d, .memad(.src0b, .add_unaligned_size, -1), ._, ._ },
                            .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0b, .tmp1b, ._, ._ },
                            .{ ._, ._nl, .j, .@"1f", ._, ._, ._ },
                            .{ ._, ._, .mov, .dst0d, .tmp1d, ._, ._ },
                            .{ .@"1:", ._c, .de, .tmp0d, ._, ._, ._ },
                            .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .cmov, .slow_incdec, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .movzx, .dst0d, .memad(.src0b, .add_unaligned_size, -1), ._, ._ },
                            .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0b, .tmp1b, ._, ._ },
                            .{ ._, ._b, .cmov, .dst0d, .tmp1d, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .cmov, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .movzx, .dst0d, .memad(.src0b, .add_unaligned_size, -1), ._, ._ },
                            .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0b, .tmp1b, ._, ._ },
                            .{ ._, ._b, .cmov, .dst0d, .tmp1d, ._, ._ },
                            .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                            .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .slow_incdec, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .movzx, .dst0d, .memad(.src0b, .add_unaligned_size, -1), ._, ._ },
                            .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0b, .tmp1b, ._, ._ },
                            .{ ._, ._nb, .j, .@"1f", ._, ._, ._ },
                            .{ ._, ._, .mov, .dst0d, .tmp1d, ._, ._ },
                            .{ .@"1:", ._, .sub, .tmp0d, .si(1), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .dst_constraints = .{ .{ .unsigned_int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .movzx, .dst0d, .memad(.src0b, .add_unaligned_size, -1), ._, ._ },
                            .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0b, .tmp1b, ._, ._ },
                            .{ ._, ._nb, .j, .@"1f", ._, ._, ._ },
                            .{ ._, ._, .mov, .dst0d, .tmp1d, ._, ._ },
                            .{ .@"1:", ._c, .de, .tmp0d, ._, ._, ._ },
                            .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .dword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .maxs, .dst0x, .src0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .dword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .maxs, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .dword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .maxu, .dst0x, .src0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .dword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .maxu, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .dword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .subus, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .add, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .maxs, .tmp0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .dst0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .maxs, .dst0x, .tmp0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .maxs, .tmp0x, .src0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .dst0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .maxs, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .maxu, .tmp0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .dst0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .maxu, .dst0x, .tmp0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .maxu, .tmp0x, .src0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .dst0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .maxu, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .subus, .tmp0x, .src0x, ._, ._ },
                            .{ ._, .p_w, .add, .tmp0x, .src0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .dst0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .subus, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .add, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .maxs, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .maxs, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .maxs, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .maxs, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .maxu, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .maxu, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .maxu, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .maxu, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .subus, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .add, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .subus, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .add, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smax, .outside = .smax } } },
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_w, .broadcast, .tmp2x, .lea(.tmp0w), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .tmp2x, .src0x, ._ },
                            .{ ._, .vp_, .@"or", .dst0x, .dst0x, .lea(.tmp0x), ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smax, .outside = .smax } } },
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ss, .broadcast, .tmp2x, .lea(.tmp0d), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .tmp2x, .src0x, ._ },
                            .{ ._, .vp_, .@"or", .dst0x, .dst0x, .lea(.tmp0x), ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smax, .outside = .smax } } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._, .movddup, .tmp3x, .lea(.tmp0q), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, .ph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp3x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smin } } },
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .maxs, .dst0x, .tmp3x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .maxs, .dst0x, .tmp3x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .maxs, .dst0x, .tmp3x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_w, .cmpeq, .tmp2x, .tmp2x, .tmp2x, ._ },
                            .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .p_w, .cmpeq, .tmp2x, .tmp2x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .ph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .subus, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .add, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .subus, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .add, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .subus, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .add, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smax, .outside = .smax } } },
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_w, .broadcast, .tmp2x, .lea(.tmp0w), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .src0x, .tmp2x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smax, .outside = .smax } } },
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ss, .broadcast, .tmp2x, .lea(.tmp0d), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .src0x, .tmp2x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smax, .outside = .smax } } },
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .ph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .maxs, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .maxs, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .maxs, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .cmpeq, .tmp0x, .tmp0x, .tmp0x, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .cmpeq, .tmp0x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .ph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .subus, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .add, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .subus, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .add, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .subus, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .add, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smax, .outside = .smax } } },
                            .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_w, .broadcast, .tmp2y, .lea(.tmp0w), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0y, .tmp2y, .src0y, ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_i128, .extract, .tmp4x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .minu, .dst0x, .dst0x, .tmp4x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smax, .outside = .smax } } },
                            .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ss, .broadcast, .tmp2y, .lea(.tmp0d), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                            .{ ._, .v_ps, .xor, .dst0y, .tmp2y, .src0y, ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_f128, .extract, .tmp4x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .minu, .dst0x, .dst0x, .tmp4x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .cmpeq, .tmp2x, .tmp2x, .tmp2x, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .cmpeq, .tmp2x, .tmp2x, .tmp2x, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smax, .outside = .smax } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_i128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_w, .maxs, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ },
                            .{ ._, .vp_w, .broadcast, .tmp0x, .lea(.tmp1w), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smax, .outside = .smax } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_w, .maxs, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ss, .broadcast, .tmp0x, .lea(.tmp1d), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_i128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_w, .maxu, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .cmpeq, .tmp0x, .tmp0x, .tmp0x, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_w, .maxu, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .cmpeq, .tmp0x, .tmp0x, .tmp0x, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .zword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smax, .outside = .smax } } },
                            .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_w, .broadcast, .tmp2y, .lea(.tmp0w), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0y, .tmp2y, .mem(.src0y), ._ },
                            .{ ._, .vp_, .xor, .tmp4y, .tmp2y, .memd(.src0y, 32), ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .vp_, .@"or", .tmp4y, .tmp4y, .lead(.tmp0y, 32), ._ },
                            .{ ._, .vp_w, .minu, .dst0y, .dst0y, .tmp4y, ._ },
                            .{ ._, .v_i128, .extract, .tmp4x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .minu, .dst0x, .dst0x, .tmp4x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp4x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .zword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp2y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .mem(.src0y), ._ },
                            .{ ._, .vp_, .@"and", .tmp2y, .tmp2y, .memd(.src0y, 32), ._ },
                            .{ ._, .vp_w, .maxu, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .cmpeq, .tmp2x, .tmp2x, .tmp2x, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .zword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smax, .outside = .smax } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .vp_w, .maxs, .dst0y, .dst0y, .memd(.src0y, 32), ._ },
                            .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .maxs, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ },
                            .{ ._, .vp_w, .broadcast, .tmp0x, .lea(.tmp1w), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .zword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .vp_w, .maxu, .dst0y, .dst0y, .memd(.src0y, 32), ._ },
                            .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .maxu, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .cmpeq, .tmp0x, .tmp0x, .tmp0x, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_signed_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .{ .type = .i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smax, .outside = .smax } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                            .{ .@"0:", .vp_w, .maxs, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .maxs, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .vp_w, .broadcast, .tmp1x, .lea(.tmp0w), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smax, .outside = .smax } } },
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .vp_w, .maxs, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ss, .broadcast, .tmp2x, .lea(.tmp0d), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smax, .outside = .smax } } },
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .p_w, .maxs, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .ph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .p_w, .maxs, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .maxs, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .maxs, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .maxs, .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_unsigned_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                            .{ .@"0:", .vp_w, .maxu, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .maxu, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .cmpeq, .tmp1x, .tmp1x, .tmp1x, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ ._, .vp_w, .cmpeq, .tmp1x, .tmp1x, .tmp1x, ._ },
                            .{ .@"0:", .vp_w, .maxu, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ ._, .p_w, .cmpeq, .tmp1x, .tmp1x, ._, ._ },
                            .{ .@"0:", .p_w, .maxu, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .ph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .p_w, .subus, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .add, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .subus, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .add, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .subus, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .add, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .subus, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .add, .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .zword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_32_i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smin } } },
                            .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } },
                            .{ .type = .i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smax, .outside = .smax } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .vp_, .@"and", .tmp3y, .tmp3y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .vp_, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ },
                            .{ .@"0:", .vp_w, .maxs, .tmp3y, .tmp3y, .memid(.src0y, .tmp0, 32), ._ },
                            .{ ._, .vp_w, .maxs, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_w, .maxs, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp4), ._, ._ },
                            .{ ._, .vp_w, .broadcast, .tmp3x, .lea(.tmp0w), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smin } } },
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .{ .type = .i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smax, .outside = .smax } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
                            .{ .@"0:", .vp_w, .maxs, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp4), ._, ._ },
                            .{ ._, .vp_w, .broadcast, .tmp3x, .lea(.tmp0w), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smin } } },
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smax, .outside = .smax } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ .@"0:", .vp_w, .maxs, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp4), ._, ._ },
                            .{ ._, .v_ss, .broadcast, .tmp3x, .lea(.tmp0d), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smin } } },
                            .{ .type = .vector_4_i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smax, .outside = .smax } } },
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ .@"0:", .p_w, .maxs, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                            .{ ._, ._, .movddup, .tmp4x, .lea(.tmp0q), ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .ph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp4x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_i16, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smin } } },
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ .@"0:", .p_w, .maxs, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .maxs, .dst0x, .tmp3x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .maxs, .dst0x, .tmp3x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .maxs, .dst0x, .tmp3x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .zword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp2y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ },
                            .{ ._, .vp_, .@"and", .tmp2y, .tmp2y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                            .{ .@"0:", .vp_w, .maxu, .tmp2y, .tmp2y, .memid(.src0y, .tmp0, 32), ._ },
                            .{ ._, .vp_w, .maxu, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_w, .maxu, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .cmpeq, .tmp2x, .tmp2x, .tmp2x, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ .@"0:", .vp_w, .maxu, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .cmpeq, .tmp2x, .tmp2x, .tmp2x, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ .@"0:", .vp_w, .maxu, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_w, .cmpeq, .tmp2x, .tmp2x, .tmp2x, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, .p_w, .cmpeq, .tmp2x, .tmp2x, ._, ._ },
                            .{ .@"0:", .p_w, .maxu, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .ph_w, .minposu, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp2x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .p_w, .subus, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .add, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .subus, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .add, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .subus, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .add, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .subus, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .add, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .cmov, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .movsx, .dst0d, .memad(.src0w, .add_unaligned_size, -2), ._, ._ },
                            .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0d, .tmp1d, ._, ._ },
                            .{ ._, ._l, .cmov, .dst0d, .tmp1d, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .dst_constraints = .{ .{ .signed_int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .movsx, .dst0d, .memad(.src0w, .add_unaligned_size, -2), ._, ._ },
                            .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0d, .tmp1d, ._, ._ },
                            .{ ._, ._nl, .j, .@"1f", ._, ._, ._ },
                            .{ ._, ._, .mov, .dst0d, .tmp1d, ._, ._ },
                            .{ .@"1:", ._, .sub, .tmp0d, .si(2), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .cmov, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .movzx, .dst0d, .memad(.src0w, .add_unaligned_size, -2), ._, ._ },
                            .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0d, .tmp1d, ._, ._ },
                            .{ ._, ._b, .cmov, .dst0d, .tmp1d, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .dst_constraints = .{ .{ .unsigned_int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .movzx, .dst0d, .memad(.src0w, .add_unaligned_size, -2), ._, ._ },
                            .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0d, .tmp1d, ._, ._ },
                            .{ ._, ._nb, .j, .@"1f", ._, ._, ._ },
                            .{ ._, ._, .mov, .dst0d, .tmp1d, ._, ._ },
                            .{ .@"1:", ._, .sub, .tmp0d, .si(2), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxs, .dst0x, .src0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .maxs, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .src0x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxu, .dst0x, .src0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .maxu, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse3, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_i32, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_i32, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxs, .tmp0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .dst0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxs, .dst0x, .tmp0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .maxs, .tmp0x, .src0x, ._, ._ },
                            .{ ._, .p_d, .shuf, .dst0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .maxs, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp1x, .src0x, ._, ._ },
                            .{ ._, .p_, .@"and", .tmp0x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp1x, .src0x, ._, ._ },
                            .{ ._, .p_, .@"or", .tmp0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .dst0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxu, .tmp0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .dst0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxu, .dst0x, .tmp0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .maxu, .tmp0x, .src0x, ._, ._ },
                            .{ ._, .p_d, .shuf, .dst0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .maxu, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse3, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_i32, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .tmp3x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"or", .tmp3x, .tmp4x, ._, ._ },
                            .{ ._, .p_w, .shufl, .dst0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_i32, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"and", .tmp3x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_, .@"or", .tmp3x, .tmp4x, ._, ._ },
                            .{ ._, .p_w, .shufl, .dst0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxs, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxs, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .maxs, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .maxs, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .src0x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxu, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxu, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .maxu, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .maxu, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse3, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_i32, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp3x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .src0x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_i32, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp3x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .src0x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_i32, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smin } } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_i32, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smin } } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_i128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_d, .maxs, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxs, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxs, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_d, .maxs, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxs, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxs, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_i128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_d, .maxu, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxu, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxu, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_d, .maxu, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxu, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxu, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .zword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_i32, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smin } } },
                            .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .mem(.src0y), ._ },
                            .{ ._, .vp_, .@"and", .tmp3y, .tmp3y, .memd(.src0y, 32), ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .vp_, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, .vp_d, .maxs, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .zword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp2y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .mem(.src0y), ._ },
                            .{ ._, .vp_, .@"and", .tmp2y, .tmp2y, .memd(.src0y, 32), ._ },
                            .{ ._, .vp_d, .maxu, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .zword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .vp_d, .maxs, .dst0y, .dst0y, .memd(.src0y, 32), ._ },
                            .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .maxs, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxs, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxs, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .zword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .vp_d, .maxu, .dst0y, .dst0y, .memd(.src0y, 32), ._ },
                            .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .maxu, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxu, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxu, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                            .{ .@"0:", .vp_d, .maxs, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .maxs, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxs, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxs, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .vp_d, .maxs, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxs, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxs, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .p_d, .maxs, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .maxs, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .maxs, .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp2x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                            .{ .@"0:", .vp_d, .maxu, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .maxu, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxu, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxu, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .vp_d, .maxu, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxu, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxu, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .p_d, .maxu, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .maxu, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .maxu, .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse3, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_i32, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp3x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .p_, .xor, .tmp3x, .tmp2x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_i32, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp3x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .p_, .xor, .tmp3x, .tmp2x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .zword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_i32, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smin } } },
                            .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .vp_, .@"and", .tmp3y, .tmp3y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .vp_, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ },
                            .{ .@"0:", .vp_d, .maxs, .tmp3y, .tmp3y, .memid(.src0y, .tmp0, 32), ._ },
                            .{ ._, .vp_d, .maxs, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .maxs, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_i32, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smin } } },
                            .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
                            .{ .@"0:", .vp_d, .maxs, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_i32, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smin } } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ .@"0:", .vp_d, .maxs, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxs, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_i32, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smin } } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ .@"0:", .p_d, .maxs, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .maxs, .dst0x, .tmp3x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .maxs, .dst0x, .tmp3x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_i32, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smin } } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp3x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp4x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .zword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp2y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ },
                            .{ ._, .vp_, .@"and", .tmp2y, .tmp2y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                            .{ .@"0:", .vp_d, .maxu, .tmp2y, .tmp2y, .memid(.src0y, .tmp0, 32), ._ },
                            .{ ._, .vp_d, .maxu, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .maxu, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ .@"0:", .vp_d, .maxu, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ .@"0:", .vp_d, .maxu, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .maxu, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ .@"0:", .p_d, .maxu, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .maxu, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .maxu, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse3, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_i32, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp4x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .p_, .xor, .tmp4x, .tmp2x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp5x, .dst0x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp5x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp5x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp5x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp5x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp4x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp5x, .dst0x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp5x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp5x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp5x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp5x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp4x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp5x, .dst0x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp5x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp5x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp5x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp5x, ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_i32, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp4x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .p_, .xor, .tmp4x, .tmp2x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp5x, .dst0x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp5x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp5x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp5x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp5x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp4x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp5x, .dst0x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp5x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp5x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp5x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp5x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp4x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp5x, .dst0x, ._, ._ },
                            .{ ._, .p_d, .cmpgt, .tmp5x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .tmp5x, ._, ._ },
                            .{ ._, .p_, .andn, .tmp5x, .tmp4x, ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .tmp5x, ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .cmov, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .mov, .dst0d, .memad(.src0d, .add_unaligned_size, -4), ._, ._ },
                            .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0d, .tmp1d, ._, ._ },
                            .{ ._, ._l, .cmov, .dst0d, .tmp1d, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .dst_constraints = .{ .{ .signed_int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .mov, .dst0d, .memad(.src0d, .add_unaligned_size, -4), ._, ._ },
                            .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0d, .tmp1d, ._, ._ },
                            .{ ._, ._nl, .j, .@"1f", ._, ._, ._ },
                            .{ ._, ._, .mov, .dst0d, .tmp1d, ._, ._ },
                            .{ .@"1:", ._, .sub, .tmp0d, .si(4), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .cmov, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .mov, .dst0d, .memad(.src0d, .add_unaligned_size, -4), ._, ._ },
                            .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0d, .tmp1d, ._, ._ },
                            .{ ._, ._b, .cmov, .dst0d, .tmp1d, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .dst_constraints = .{ .{ .unsigned_int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .mov, .dst0d, .memad(.src0d, .add_unaligned_size, -4), ._, ._ },
                            .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0d, .tmp1d, ._, ._ },
                            .{ ._, ._nb, .j, .@"1f", ._, ._, ._ },
                            .{ ._, ._, .mov, .dst0d, .tmp1d, ._, ._ },
                            .{ .@"1:", ._, .sub, .tmp0d, .si(4), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp1x, .tmp0x, .src0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .src0x, .tmp0x, .tmp1x },
                        } },
                    }, .{
                        .required_features = .{ .sse4_2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, .p_q, .cmpgt, .tmp1x, .src0x, ._, ._ },
                            .{ ._, .p_b, .blendv, .dst0x, .tmp0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .tmp2x, .src0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .tmp3x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_q, .cmpgt, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_b, .blendv, .dst0x, .tmp3x, .tmp4x, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp1x, .tmp0x, .src0x, ._ },
                            .{ ._, .vp_b, .blendv, .tmp0x, .src0x, .tmp0x, .tmp1x },
                            .{ ._, .v_i128, .extract, .dst0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .tmp0x, .dst0x, .tmp1x },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp1x, .tmp0x, .src0x, ._ },
                            .{ ._, .vp_b, .blendv, .tmp0x, .src0x, .tmp0x, .tmp1x },
                            .{ ._, .v_f128, .extract, .dst0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .tmp0x, .dst0x, .tmp1x },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0y, .tmp2y, .src0y, ._ },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .tmp3x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .tmp3x, .dst0x, .tmp3x, .tmp4x },
                            .{ ._, .v_i128, .extract, .dst0x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .tmp3x, .dst0x, .tmp4x },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_sd, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ },
                            .{ ._, .v_pd, .xor, .dst0y, .tmp2y, .src0y, ._ },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .tmp3x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .tmp3x, .dst0x, .tmp3x, .tmp4x },
                            .{ ._, .v_f128, .extract, .dst0x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .tmp3x, .dst0x, .tmp4x },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_i128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp1x, .tmp0x, .src0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .src0x, .tmp0x, .tmp1x },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp1x, .tmp0x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp0x, .tmp1x },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp1x, .tmp0x, .src0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .src0x, .tmp0x, .tmp1x },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp1x, .tmp0x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp0x, .tmp1x },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0y, .tmp2y, .src0y, ._ },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .tmp3x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .tmp3x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_sd, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ },
                            .{ ._, .v_pd, .xor, .dst0y, .tmp2y, .src0y, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .tmp3x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .tmp3x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_signed_int = .{ .of = .zword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smin } } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .mem(.src0y), ._ },
                            .{ ._, .vp_, .@"and", .tmp3y, .tmp3y, .memd(.src0y, 32), ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .vp_, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4y, .tmp3y, .dst0y, ._ },
                            .{ ._, .vp_b, .blendv, .dst0y, .dst0y, .tmp3y, .tmp4y },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .tmp3x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .tmp3x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_unsigned_int = .{ .of = .zword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp4y, .memd(.src0y, 32), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .vp_, .@"and", .tmp4y, .tmp4y, .lead(.tmp0y, 32), ._ },
                            .{ ._, .vp_, .xor, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .vp_, .xor, .tmp4y, .tmp4y, .tmp2y, ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp5y, .tmp4y, .dst0y, ._ },
                            .{ ._, .vp_b, .blendv, .dst0y, .dst0y, .tmp4y, .tmp5y },
                            .{ ._, .v_i128, .extract, .tmp4x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp5x, .tmp4x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp4x, .tmp5x },
                            .{ ._, .vp_d, .shuf, .tmp4x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp5x, .tmp4x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp4x, .tmp5x },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_signed_int = .{ .of = .zword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp0y, .memd(.src0y, 32), ._, ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp1y, .tmp0y, .dst0y, ._ },
                            .{ ._, .vp_b, .blendv, .dst0y, .dst0y, .tmp0y, .tmp1y },
                            .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp1x, .tmp0x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp0x, .tmp1x },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp1x, .tmp0x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp0x, .tmp1x },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_unsigned_int = .{ .of = .zword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0y, .tmp2y, .mem(.src0y), ._ },
                            .{ ._, .vp_, .xor, .tmp3y, .tmp2y, .memd(.src0y, 32), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4y, .tmp3y, .dst0y, ._ },
                            .{ ._, .vp_b, .blendv, .dst0y, .dst0y, .tmp3y, .tmp4y },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .tmp3x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .tmp3x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                            .{ .@"0:", .v_dqa, .mov, .tmp1y, .memi(.src0y, .tmp0), ._, ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp2y, .tmp1y, .dst0y, ._ },
                            .{ ._, .vp_b, .blendv, .dst0y, .dst0y, .tmp1y, .tmp2y },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp2x, .tmp1x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp1x, .tmp2x },
                            .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp2x, .tmp1x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp1x, .tmp2x },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp2x, .tmp1x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp1x, .tmp2x },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp2x, .tmp1x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp1x, .tmp2x },
                        } },
                    }, .{
                        .required_features = .{ .sse4_2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, .p_q, .cmpgt, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, .p_b, .blendv, .dst0x, .tmp1x, .tmp2x, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, .p_q, .cmpgt, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, .p_b, .blendv, .dst0x, .tmp1x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0y, .tmp2y, .memad(.src0y, .add_unaligned_size, -32), ._ },
                            .{ .@"0:", .vp_, .xor, .tmp3y, .tmp2y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4y, .tmp3y, .dst0y, ._ },
                            .{ ._, .vp_b, .blendv, .dst0y, .dst0y, .tmp3y, .tmp4y },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .tmp3x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .tmp3x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .vp_, .xor, .dst0x, .tmp2x, .memad(.src0x, .add_unaligned_size, -16), ._ },
                            .{ .@"0:", .vp_, .xor, .tmp3x, .tmp2x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .tmp3x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .tmp3x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp3x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .p_, .xor, .tmp3x, .tmp2x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_q, .cmpgt, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_b, .blendv, .dst0x, .tmp3x, .tmp4x, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_q, .cmpgt, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_b, .blendv, .dst0x, .tmp3x, .tmp4x, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .zword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smin } } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .vp_, .@"and", .tmp3y, .tmp3y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .vp_, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-96, .src0, .add_size), ._, ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4y, .tmp3y, .dst0y, ._ },
                            .{ ._, .vp_b, .blendv, .dst0y, .dst0y, .tmp3y, .tmp4y },
                            .{ .@"0:", .v_dqa, .mov, .tmp3y, .memi(.src0y, .tmp0), ._, ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4y, .tmp3y, .dst0y, ._ },
                            .{ ._, .vp_b, .blendv, .dst0y, .dst0y, .tmp3y, .tmp4y },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .tmp3x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .tmp3x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smin } } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .vp_, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
                            .{ .@"0:", .v_dqa, .mov, .tmp3y, .memi(.src0y, .tmp0), ._, ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4y, .tmp3y, .dst0y, ._ },
                            .{ ._, .vp_b, .blendv, .dst0y, .dst0y, .tmp3y, .tmp4y },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .tmp3x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .tmp3x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smin } } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .tmp3x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                            .{ .@"0:", .v_dqa, .mov, .tmp3x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .tmp3x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp4x, .tmp3x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp3x, .tmp4x },
                        } },
                    }, .{
                        .required_features = .{ .sse4_2, null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_2_i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .outside = .smin } } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, .p_, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp3x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_q, .cmpgt, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_b, .blendv, .dst0x, .tmp3x, .tmp4x, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp3x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, .p_q, .cmpgt, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, .p_b, .blendv, .dst0x, .tmp3x, .tmp4x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .zword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp4y, .memad(.src0y, .add_size, -32), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_size, -64), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .vp_, .@"and", .tmp4y, .tmp4y, .lead(.tmp0y, 32), ._ },
                            .{ ._, .vp_, .xor, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .vp_, .xor, .tmp4y, .tmp4y, .tmp2y, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-96, .src0, .add_size), ._, ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp5y, .tmp4y, .dst0y, ._ },
                            .{ ._, .vp_b, .blendv, .dst0y, .dst0y, .tmp4y, .tmp5y },
                            .{ .@"0:", .vp_, .xor, .tmp4y, .tmp2y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp5y, .tmp4y, .dst0y, ._ },
                            .{ ._, .vp_b, .blendv, .dst0y, .dst0y, .tmp4y, .tmp5y },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp4x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp5x, .tmp4x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp4x, .tmp5x },
                            .{ ._, .vp_d, .shuf, .tmp4x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp5x, .tmp4x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp4x, .tmp5x },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_size, -32), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .vp_, .xor, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
                            .{ .@"0:", .vp_, .xor, .tmp4y, .tmp2y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp5y, .tmp4y, .dst0y, ._ },
                            .{ ._, .vp_b, .blendv, .dst0y, .dst0y, .tmp4y, .tmp5y },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp4x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp5x, .tmp4x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp4x, .tmp5x },
                            .{ ._, .vp_d, .shuf, .tmp4x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp5x, .tmp4x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp4x, .tmp5x },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_sd, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .memad(.src0y, .add_size, -32), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_ps, .xor, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp4x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp5x, .tmp4x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp4x, .tmp5x },
                            .{ .@"0:", .vp_, .xor, .tmp4x, .tmp2x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp5x, .tmp4x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp4x, .tmp5x },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .shuf, .tmp4x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .cmpgt, .tmp5x, .tmp4x, .dst0x, ._ },
                            .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp4x, .tmp5x },
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_2, null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i64, .kind = .{ .splat_int_mem = .{ .ref = .src0, .inside = .smin, .outside = .smin } } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp4x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .p_, .xor, .tmp4x, .tmp2x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp5x, .tmp4x, ._, ._ },
                            .{ ._, .p_q, .cmpgt, .tmp5x, .dst0x, ._, ._ },
                            .{ ._, .p_b, .blendv, .dst0x, .tmp4x, .tmp5x, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp4x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, ._dqa, .mov, .tmp5x, .tmp4x, ._, ._ },
                            .{ ._, .p_q, .cmpgt, .tmp5x, .dst0x, ._, ._ },
                            .{ ._, .p_b, .blendv, .dst0x, .tmp4x, .tmp5x, ._ },
                            .{ ._, .p_, .xor, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .@"64bit", .cmov, null, null },
                        .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .mov, .dst0q, .memad(.src0q, .add_unaligned_size, -8), ._, ._ },
                            .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0q, .tmp1q, ._, ._ },
                            .{ ._, ._l, .cmov, .dst0q, .tmp1q, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .@"64bit", null, null, null },
                        .dst_constraints = .{ .{ .signed_int = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .mov, .dst0q, .memad(.src0q, .add_unaligned_size, -8), ._, ._ },
                            .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0q, .tmp1q, ._, ._ },
                            .{ ._, ._nl, .j, .@"1f", ._, ._, ._ },
                            .{ ._, ._, .mov, .dst0q, .tmp1q, ._, ._ },
                            .{ .@"1:", ._, .sub, .tmp0d, .si(8), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .@"64bit", .cmov, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .mov, .dst0q, .memad(.src0q, .add_unaligned_size, -8), ._, ._ },
                            .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0q, .tmp1q, ._, ._ },
                            .{ ._, ._b, .cmov, .dst0q, .tmp1q, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .@"64bit", null, null, null },
                        .dst_constraints = .{ .{ .unsigned_int = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .mov, .dst0q, .memad(.src0q, .add_unaligned_size, -8), ._, ._ },
                            .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                            .{ ._, ._, .cmp, .dst0q, .tmp1q, ._, ._ },
                            .{ ._, ._nb, .j, .@"1f", ._, ._, ._ },
                            .{ ._, ._, .mov, .dst0q, .tmp1q, ._, ._ },
                            .{ .@"1:", ._, .sub, .tmp0d, .si(8), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .@"64bit", .cmov, null, null },
                        .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                        .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .reg = .rdi } },
                            .{ .type = .usize, .kind = .{ .reg = .rsi } },
                            .{ .type = .isize, .kind = .{ .reg = .rcx } },
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_unaligned_size_sub_2_elem_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                            .{ .@"0:", ._, .mov, .tmp2p, .sia(1, .dst0, .sub_size_div_8), ._, ._ },
                            .{ ._, ._, .lea, .tmp3p, .memi(.src0, .tmp0), ._, ._ },
                            .{ ._, ._c, .cl, ._, ._, ._, ._ },
                            .{ .@"1:", ._, .mov, .tmp4q, .leasiad(.tmp1q, .@"8", .tmp2, .add_src0_elem_size, -8), ._, ._ },
                            .{ ._, ._, .sbb, .tmp4q, .leasiad(.tmp3q, .@"8", .tmp2, .add_src0_elem_size, -8), ._, ._ },
                            .{ ._, ._c, .in, .tmp2p, ._, ._, ._ },
                            .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                            .{ ._, ._, .mov, .tmp4q, .leaad(.tmp1q, .add_src0_elem_size, -8), ._, ._ },
                            .{ ._, ._, .sbb, .tmp4q, .leaad(.tmp3q, .add_src0_elem_size, -8), ._, ._ },
                            .{ ._, ._l, .cmov, .tmp1p, .tmp3p, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .sa(.dst0, .add_size), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                            .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_size_div_8), ._, ._ },
                            .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .@"64bit", null, null, null },
                        .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any },
                        .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .reg = .rdi } },
                            .{ .type = .usize, .kind = .{ .reg = .rsi } },
                            .{ .type = .isize, .kind = .{ .reg = .rcx } },
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_unaligned_size_sub_2_elem_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                            .{ .@"0:", ._, .mov, .tmp2p, .sia(1, .dst0, .sub_size_div_8), ._, ._ },
                            .{ ._, ._, .lea, .tmp3p, .memi(.src0, .tmp0), ._, ._ },
                            .{ ._, ._c, .cl, ._, ._, ._, ._ },
                            .{ .@"1:", ._, .mov, .tmp4q, .leasiad(.tmp1q, .@"8", .tmp2, .add_src0_elem_size, -8), ._, ._ },
                            .{ ._, ._, .sbb, .tmp4q, .leasiad(.tmp3q, .@"8", .tmp2, .add_src0_elem_size, -8), ._, ._ },
                            .{ ._, ._c, .in, .tmp2p, ._, ._, ._ },
                            .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                            .{ ._, ._, .mov, .tmp4q, .leaad(.tmp1q, .add_src0_elem_size, -8), ._, ._ },
                            .{ ._, ._, .sbb, .tmp4q, .leaad(.tmp3q, .add_src0_elem_size, -8), ._, ._ },
                            .{ ._, ._nl, .j, .@"1f", ._, ._, ._ },
                            .{ ._, ._, .mov, .tmp1p, .tmp3p, ._, ._ },
                            .{ .@"1:", ._, .sub, .tmp0d, .sa(.dst0, .add_size), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                            .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_size_div_8), ._, ._ },
                            .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .@"64bit", .cmov, null, null },
                        .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
                        .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .reg = .rdi } },
                            .{ .type = .usize, .kind = .{ .reg = .rsi } },
                            .{ .type = .isize, .kind = .{ .reg = .rcx } },
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_unaligned_size_sub_2_elem_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                            .{ .@"0:", ._, .mov, .tmp2p, .sa(.dst0, .sub_size_div_8), ._, ._ },
                            .{ ._, ._, .lea, .tmp3p, .memi(.src0, .tmp0), ._, ._ },
                            .{ ._, ._c, .cl, ._, ._, ._, ._ },
                            .{ .@"1:", ._, .mov, .tmp4q, .leasia(.tmp1q, .@"8", .tmp2, .add_src0_elem_size), ._, ._ },
                            .{ ._, ._, .sbb, .tmp4q, .leasia(.tmp3q, .@"8", .tmp2, .add_src0_elem_size), ._, ._ },
                            .{ ._, ._c, .in, .tmp2p, ._, ._, ._ },
                            .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                            .{ ._, ._b, .cmov, .tmp1p, .tmp3p, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .sa(.dst0, .add_size), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                            .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_size_div_8), ._, ._ },
                            .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .@"64bit", null, null, null },
                        .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } }, .any },
                        .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .reg = .rdi } },
                            .{ .type = .usize, .kind = .{ .reg = .rsi } },
                            .{ .type = .isize, .kind = .{ .reg = .rcx } },
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_unaligned_size_sub_2_elem_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                            .{ .@"0:", ._, .mov, .tmp2p, .sa(.dst0, .sub_size_div_8), ._, ._ },
                            .{ ._, ._, .lea, .tmp3p, .memi(.src0, .tmp0), ._, ._ },
                            .{ ._, ._c, .cl, ._, ._, ._, ._ },
                            .{ .@"1:", ._, .mov, .tmp4q, .leasia(.tmp1q, .@"8", .tmp2, .add_src0_elem_size), ._, ._ },
                            .{ ._, ._, .sbb, .tmp4q, .leasia(.tmp3q, .@"8", .tmp2, .add_src0_elem_size), ._, ._ },
                            .{ ._, ._c, .in, .tmp2p, ._, ._, ._ },
                            .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                            .{ ._, ._nb, .j, .@"1f", ._, ._, ._ },
                            .{ ._, ._, .mov, .tmp1p, .tmp3p, ._, ._ },
                            .{ .@"1:", ._, .sub, .tmp0d, .sa(.dst0, .add_size), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                            .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_size_div_8), ._, ._ },
                            .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .dword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ss, .max, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .max, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_f16, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = -nan } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"or", .dst0x, .src0x, .lea(.tmp0x), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .max, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .max, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .max, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .max, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_f16, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = -nan } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp3y, .tmp3x, ._, ._ },
                            .{ ._, .v_ps, .max, .tmp4y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3y, .tmp3y, .tmp3y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp4y, .tmp3y },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .max, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .max, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp0y, .tmp0x, ._, ._ },
                            .{ ._, .v_ps, .max, .tmp1y, .dst0y, .tmp0y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp0y, .tmp0y, .tmp0y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp1y, .tmp0y },
                            .{ ._, .v_f128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .max, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .max, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .zword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_32_f16, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = -nan } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_ps, .mova, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"and", .tmp3y, .tmp3y, .memd(.src0y, 32), ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .mem(.src0y), ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_ps, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, .v_f128, .extract, .tmp4x, .tmp3y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp3y, .tmp3x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp4y, .tmp4x, ._, ._ },
                            .{ ._, .v_ps, .max, .tmp5y, .tmp3y, .tmp4y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp4y, .tmp4y, .tmp4y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .tmp3y, .tmp3y, .tmp5y, .tmp4y },
                            .{ ._, .v_f128, .extract, .tmp4x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp4y, .tmp4x, ._, ._ },
                            .{ ._, .v_ps, .max, .tmp5y, .dst0y, .tmp4y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp4y, .tmp4y, .tmp4y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp5y, .tmp4y },
                            .{ ._, .v_ps, .max, .tmp4y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3y, .tmp3y, .tmp3y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp4y, .tmp3y },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .max, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .max, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .zword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .mova, .tmp0y, .memd(.src0y, 32), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp1x, .tmp0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp0y, .tmp0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp1y, .tmp1x, ._, ._ },
                            .{ ._, .v_ps, .max, .tmp2y, .tmp0y, .tmp1y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp1y, .tmp1y, .tmp1y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .tmp0y, .tmp0y, .tmp2y, .tmp1y },
                            .{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp1y, .tmp1x, ._, ._ },
                            .{ ._, .v_ps, .max, .tmp2y, .dst0y, .tmp1y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp1y, .tmp1y, .tmp1y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp2y, .tmp1y },
                            .{ ._, .v_ps, .max, .tmp1y, .dst0y, .tmp0y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp0y, .tmp0y, .tmp0y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp1y, .tmp0y },
                            .{ ._, .v_f128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .max, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .max, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_float = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .v_ps, .max, .tmp2y, .dst0y, .tmp1y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp1y, .tmp1y, .tmp1y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp2y, .tmp1y },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .max, .tmp2x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp1x, .tmp1x, .tmp1x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp2x, .tmp1x },
                            .{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .max, .tmp2x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp1x, .tmp1x, .tmp1x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp2x, .tmp1x },
                            .{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .tmp2x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp1x, .tmp1x, .tmp1x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp2x, .tmp1x },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .zword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_32_f16, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = -nan } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_ps, .mova, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"and", .tmp3y, .tmp3y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_ps, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-80, .src0, .add_size), ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp4x, .tmp3y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp3y, .tmp3x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp4y, .tmp4x, ._, ._ },
                            .{ ._, .v_ps, .max, .tmp5y, .tmp3y, .tmp4y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp4y, .tmp4y, .tmp4y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .tmp3y, .tmp3y, .tmp5y, .tmp4y },
                            .{ ._, .v_f128, .extract, .tmp4x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp4y, .tmp4x, ._, ._ },
                            .{ ._, .v_ps, .max, .tmp5y, .dst0y, .tmp4y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp4y, .tmp4y, .tmp4y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp5y, .tmp4y },
                            .{ ._, .v_ps, .max, .tmp4y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3y, .tmp3y, .tmp3y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp4y, .tmp3y },
                            .{ .@"0:", .v_ps, .cvtph2, .tmp3y, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .v_ps, .max, .tmp4y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3y, .tmp3y, .tmp3y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp4y, .tmp3y },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .max, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .max, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_f16, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = -nan } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp3y, .tmp3x, ._, ._ },
                            .{ ._, .v_ps, .max, .tmp4y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3y, .tmp3y, .tmp3y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp4y, .tmp3y },
                            .{ .@"0:", .v_ps, .cvtph2, .tmp3y, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .v_ps, .max, .tmp4y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3y, .tmp3y, .tmp3y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp4y, .tmp3y },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .max, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .max, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__fmaxh" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .vp_w, .insr, .dst0x, .dst0x, .memad(.src0w, .add_unaligned_size, -2), .ui(0) },
                            .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
                            .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__fmaxh" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, .p_, .xor, .dst0x, .dst0x, ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .p_w, .insr, .dst0x, .memad(.src0w, .add_unaligned_size, -2), .ui(0), ._ },
                            .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f16, .kind = .{ .reg = .ax } },
                            .{ .type = .f32, .kind = .mem },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__fmaxh" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .movzx, .tmp1d, .memad(.src0w, .add_unaligned_size, -2), ._, ._ },
                            .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                            .{ ._, ._ss, .mov, .dst0x, .mem(.tmp2d), ._, ._ },
                            .{ .@"0:", ._ps, .xor, .tmp3x, .tmp3x, ._, ._ },
                            .{ ._, ._ss, .mov, .tmp3x, .memi(.src0d, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .shuf, .tmp0x, .src0x, .src0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .tmp1x, .src0x, .tmp0x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .src0x, .tmp1x, .tmp0x },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .reg = .xmm0 } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .mova, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .tmp0x, .tmp0x, .ui(0b01), ._ },
                            .{ ._, ._ps, .mova, .tmp1x, .src0x, ._, ._ },
                            .{ ._, ._ss, .max, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, ._ss, .cmp, .tmp0x, .tmp0x, .sp(.ord), ._ },
                            .{ ._, ._ps, .blendv, .dst0x, .tmp1x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .mova, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .tmp0x, .tmp0x, .ui(0b01), ._ },
                            .{ ._, ._ps, .mova, .tmp1x, .src0x, ._, ._ },
                            .{ ._, ._ss, .max, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, ._ss, .cmp, .tmp0x, .tmp0x, .sp(.unord), ._ },
                            .{ ._, ._ps, .@"and", .dst0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .andn, .tmp0x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .@"or", .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .movhl, .tmp0x, .src0x, .src0x, ._ },
                            .{ ._, .v_ss, .max, .tmp1x, .src0x, .tmp0x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .tmp0x, .src0x, .tmp1x, .tmp0x },
                            .{ ._, .v_ps, .shuf, .dst0x, .src0x, .src0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .tmp1x, .tmp0x, .dst0x, ._ },
                            .{ ._, .v_ss, .cmp, .dst0x, .dst0x, .dst0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .tmp0x, .tmp1x, .dst0x },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .reg = .xmm0 } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .xor, .tmp0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._ps, .mova, .tmp1x, .src0x, ._, ._ },
                            .{ ._, ._ss, .max, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, ._ss, .cmp, .tmp0x, .tmp0x, .sp(.unord), ._ },
                            .{ ._, ._ps, .blendv, .tmp1x, .src0x, .tmp0x, ._ },
                            .{ ._, ._ps, .shuf, .dst0x, .src0x, .ui(0b01), ._ },
                            .{ ._, ._ps, .mova, .tmp0x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .mova, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, ._ss, .max, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, ._ss, .cmp, .tmp0x, .tmp0x, .sp(.ord), ._ },
                            .{ ._, ._ps, .blendv, .dst0x, .tmp1x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .xor, .tmp0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._ps, .mova, .tmp1x, .src0x, ._, ._ },
                            .{ ._, ._ss, .max, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, ._ss, .cmp, .tmp0x, .tmp0x, .sp(.ord), ._ },
                            .{ ._, ._ps, .@"and", .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .andn, .tmp0x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .@"or", .tmp0x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .shuf, .dst0x, .src0x, .ui(0b01), ._ },
                            .{ ._, ._ps, .mova, .tmp1x, .src0x, ._, ._ },
                            .{ ._, ._ss, .max, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, ._ss, .cmp, .tmp0x, .tmp0x, .sp(.unord), ._ },
                            .{ ._, ._ps, .@"and", .dst0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .andn, .tmp0x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .@"or", .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .movhl, .tmp0x, .src0x, .src0x, ._ },
                            .{ ._, .v_ps, .max, .tmp1x, .src0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .src0x, .tmp1x, .tmp0x },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .reg = .xmm0 } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .xor, .tmp0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._ps, .mova, .tmp1x, .src0x, ._, ._ },
                            .{ ._, ._ps, .max, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .cmp, .tmp0x, .tmp0x, .sp(.ord), ._ },
                            .{ ._, ._ps, .blendv, .dst0x, .tmp1x, .tmp0x, ._ },
                            .{ ._, ._ps, .mova, .tmp0x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .tmp0x, .tmp0x, .ui(0b01), ._ },
                            .{ ._, ._ps, .mova, .tmp1x, .src0x, ._, ._ },
                            .{ ._, ._ss, .max, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, ._ss, .cmp, .tmp0x, .tmp0x, .sp(.ord), ._ },
                            .{ ._, ._ps, .blendv, .dst0x, .tmp1x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .xor, .tmp0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._ps, .mova, .tmp1x, .src0x, ._, ._ },
                            .{ ._, ._ps, .max, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .cmp, .tmp0x, .tmp0x, .sp(.unord), ._ },
                            .{ ._, ._ps, .@"and", .dst0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .andn, .tmp0x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .@"or", .dst0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .mova, .tmp0x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .tmp0x, .tmp0x, .ui(0b01), ._ },
                            .{ ._, ._ps, .mova, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, ._ss, .max, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, ._ss, .cmp, .tmp0x, .tmp0x, .sp(.unord), ._ },
                            .{ ._, ._ps, .@"and", .dst0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .andn, .tmp0x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .@"or", .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_f32, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = -nan } } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .max, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_ps, .movhl, .tmp3x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .max, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .v_ps, .max, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                            .{ ._, .v_ps, .movhl, .tmp0x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .max, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .zword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_f32, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = -nan } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_ps, .mova, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .mem(.src0y), ._ },
                            .{ ._, .v_ps, .@"and", .tmp3y, .tmp3y, .memd(.src0y, 32), ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_ps, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, .v_ps, .max, .tmp4y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3y, .tmp3y, .tmp3y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp4y, .tmp3y },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .max, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_ps, .movhl, .tmp3x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .max, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .zword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .mova, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .v_ps, .mova, .tmp0y, .memd(.src0y, 32), ._, ._ },
                            .{ ._, .v_ps, .max, .tmp1y, .dst0y, .tmp0y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp0y, .tmp0y, .tmp0y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp1y, .tmp0y },
                            .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .max, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                            .{ ._, .v_ps, .movhl, .tmp0x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .max, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                            .{ .@"0:", .v_ps, .mova, .tmp1y, .memi(.src0y, .tmp0), ._, ._ },
                            .{ ._, .v_ps, .max, .tmp2y, .dst0y, .tmp1y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp1y, .tmp1y, .tmp1y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp2y, .tmp1y },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .max, .tmp2x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp1x, .tmp1x, .tmp1x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp2x, .tmp1x },
                            .{ ._, .v_ps, .movhl, .tmp1x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .max, .tmp2x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp1x, .tmp1x, .tmp1x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp2x, .tmp1x },
                            .{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .tmp2x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp1x, .tmp1x, .tmp1x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp2x, .tmp1x },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_f32, .kind = .{ .reg = .xmm0 } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._ps, .mova, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._ps, .mova, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .max, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .cmp, .tmp1x, .tmp1x, .sp(.ord), ._ },
                            .{ ._, ._ps, .blendv, .dst0x, .tmp2x, .tmp1x, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .mova, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .max, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .cmp, .tmp1x, .tmp1x, .sp(.ord), ._ },
                            .{ ._, ._ps, .blendv, .dst0x, .tmp2x, .tmp1x, ._ },
                            .{ ._, ._ps, .mova, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .tmp1x, .tmp1x, .ui(0b01), ._ },
                            .{ ._, ._ps, .mova, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, ._ss, .max, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, ._ss, .cmp, .tmp1x, .tmp1x, .sp(.ord), ._ },
                            .{ ._, ._ps, .blendv, .dst0x, .tmp2x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._ps, .mova, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._ps, .mova, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .max, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .cmp, .tmp1x, .tmp1x, .sp(.unord), ._ },
                            .{ ._, ._ps, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .andn, .tmp1x, .tmp2x, ._, ._ },
                            .{ ._, ._ps, .@"or", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .mova, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .max, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .cmp, .tmp1x, .tmp1x, .sp(.unord), ._ },
                            .{ ._, ._ps, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .andn, .tmp1x, .tmp2x, ._, ._ },
                            .{ ._, ._ps, .@"or", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .mova, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .tmp1x, .tmp1x, .ui(0b01), ._ },
                            .{ ._, ._ps, .mova, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, ._ss, .max, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, ._ss, .cmp, .tmp1x, .tmp1x, .sp(.unord), ._ },
                            .{ ._, ._ps, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .andn, .tmp1x, .tmp2x, ._, ._ },
                            .{ ._, ._ps, .@"or", .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .zword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_f32, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = -nan } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_ps, .mova, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"and", .tmp3y, .tmp3y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_ps, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, .v_ps, .max, .tmp4y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3y, .tmp3y, .tmp3y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp4y, .tmp3y },
                            .{ ._, ._, .mov, .tmp0d, .sia(-96, .src0, .add_size), ._, ._ },
                            .{ .@"0:", .v_ps, .mova, .tmp3y, .memi(.src0y, .tmp0), ._, ._ },
                            .{ ._, .v_ps, .max, .tmp4y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3y, .tmp3y, .tmp3y, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp4y, .tmp3y },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .max, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_ps, .movhl, .tmp3x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .max, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_f32, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = -nan } } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .max, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ .@"0:", .v_ps, .mova, .tmp3x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .v_ps, .max, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_ps, .movhl, .tmp3x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .max, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ss, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_f32, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = -nan } } },
                            .{ .type = .vector_4_f32, .kind = .{ .reg = .xmm0 } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._ps, .mova, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, ._ps, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, ._ps, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ .@"0:", ._ps, .mova, .tmp3x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._ps, .mova, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .max, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, ._ps, .cmp, .tmp3x, .tmp3x, .sp(.ord), ._ },
                            .{ ._, ._ps, .blendv, .dst0x, .tmp4x, .tmp3x, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._ps, .xor, .tmp3x, .tmp3x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp3x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .mova, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .max, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, ._ps, .cmp, .tmp3x, .tmp3x, .sp(.ord), ._ },
                            .{ ._, ._ps, .blendv, .dst0x, .tmp4x, .tmp3x, ._ },
                            .{ ._, ._ps, .mova, .tmp3x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .tmp3x, .tmp3x, .ui(0b01), ._ },
                            .{ ._, ._ps, .mova, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, ._ss, .max, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, ._ss, .cmp, .tmp3x, .tmp3x, .sp(.ord), ._ },
                            .{ ._, ._ps, .blendv, .dst0x, .tmp4x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_f32, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = -nan } } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._ps, .mova, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, ._ps, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, ._ps, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ .@"0:", ._ps, .mova, .tmp3x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._ps, .mova, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .max, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, ._ps, .cmp, .tmp3x, .tmp3x, .sp(.unord), ._ },
                            .{ ._, ._ps, .@"and", .dst0x, .tmp3x, ._, ._ },
                            .{ ._, ._ps, .andn, .tmp3x, .tmp4x, ._, ._ },
                            .{ ._, ._ps, .@"or", .dst0x, .tmp3x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._ps, .xor, .tmp3x, .tmp3x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp3x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .mova, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .max, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, ._ps, .cmp, .tmp3x, .tmp3x, .sp(.unord), ._ },
                            .{ ._, ._ps, .@"and", .dst0x, .tmp3x, ._, ._ },
                            .{ ._, ._ps, .andn, .tmp3x, .tmp4x, ._, ._ },
                            .{ ._, ._ps, .@"or", .dst0x, .tmp3x, ._, ._ },
                            .{ ._, ._ps, .mova, .tmp3x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .tmp3x, .tmp3x, .ui(0b01), ._ },
                            .{ ._, ._ps, .mova, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, ._ss, .max, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, ._ss, .cmp, .tmp3x, .tmp3x, .sp(.unord), ._ },
                            .{ ._, ._ps, .@"and", .dst0x, .tmp3x, ._, ._ },
                            .{ ._, ._ps, .andn, .tmp3x, .tmp4x, ._, ._ },
                            .{ ._, ._ps, .@"or", .dst0x, .tmp3x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .movhl, .tmp0x, .src0x, .src0x, ._ },
                            .{ ._, .v_sd, .max, .tmp1x, .src0x, .tmp0x, ._ },
                            .{ ._, .v_sd, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0x, .src0x, .tmp1x, .tmp0x },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_f64, .kind = .{ .reg = .xmm0 } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .xor, .tmp0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._pd, .mova, .tmp1x, .src0x, ._, ._ },
                            .{ ._, ._sd, .max, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, ._sd, .cmp, .tmp0x, .tmp0x, .sp(.ord), ._ },
                            .{ ._, ._pd, .blendv, .dst0x, .tmp1x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .xor, .tmp0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._pd, .mova, .tmp1x, .src0x, ._, ._ },
                            .{ ._, ._sd, .max, .tmp1x, .tmp0x, ._, ._ },
                            .{ ._, ._sd, .cmp, .tmp0x, .tmp0x, .sp(.unord), ._ },
                            .{ ._, ._pd, .@"and", .dst0x, .tmp0x, ._, ._ },
                            .{ ._, ._pd, .andn, .tmp0x, .tmp1x, ._, ._ },
                            .{ ._, ._pd, .@"or", .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .v_sd, .max, .tmp1x, .src0x, .tmp0x, ._ },
                            .{ ._, .v_sd, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .tmp0x, .src0x, .tmp1x, .tmp0x },
                            .{ ._, .v_ps, .movhl, .dst0x, .src0x, .src0x, ._ },
                            .{ ._, .v_sd, .max, .tmp1x, .tmp0x, .dst0x, ._ },
                            .{ ._, .v_sd, .cmp, .dst0x, .dst0x, .dst0x, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0x, .tmp0x, .tmp1x, .dst0x },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .v_pd, .max, .tmp1x, .src0x, .tmp0x, ._ },
                            .{ ._, .v_pd, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0x, .src0x, .tmp1x, .tmp0x },
                            .{ ._, .v_ps, .movhl, .tmp0x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_sd, .max, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_sd, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .zword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_f64, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = -nan } } },
                            .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_pd, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_pd, .mova, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_pd, .@"and", .dst0y, .dst0y, .mem(.src0y), ._ },
                            .{ ._, .v_pd, .@"and", .tmp3y, .tmp3y, .memd(.src0y, 32), ._ },
                            .{ ._, .v_pd, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_pd, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, .v_pd, .max, .tmp4y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_pd, .cmp, .tmp3y, .tmp3y, .tmp3y, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0y, .dst0y, .tmp4y, .tmp3y },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_pd, .max, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_pd, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_ps, .movhl, .tmp3x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_sd, .max, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_sd, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .zword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_pd, .mova, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .v_pd, .mova, .tmp0y, .memd(.src0y, 32), ._, ._ },
                            .{ ._, .v_pd, .max, .tmp1y, .dst0y, .tmp0y, ._ },
                            .{ ._, .v_pd, .cmp, .tmp0y, .tmp0y, .tmp0y, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0y, .dst0y, .tmp1y, .tmp0y },
                            .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_pd, .max, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_pd, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                            .{ ._, .v_ps, .movhl, .tmp0x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_sd, .max, .tmp1x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_sd, .cmp, .tmp0x, .tmp0x, .tmp0x, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .tmp1x, .tmp0x },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_pd, .mova, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                            .{ .@"0:", .v_pd, .mova, .tmp1y, .memi(.src0y, .tmp0), ._, ._ },
                            .{ ._, .v_pd, .max, .tmp2y, .dst0y, .tmp1y, ._ },
                            .{ ._, .v_pd, .cmp, .tmp1y, .tmp1y, .tmp1y, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0y, .dst0y, .tmp2y, .tmp1y },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_pd, .max, .tmp2x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_pd, .cmp, .tmp1x, .tmp1x, .tmp1x, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .tmp2x, .tmp1x },
                            .{ ._, .v_pd, .cmp, .tmp1x, .tmp1x, .tmp1x, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .tmp2x, .tmp1x },
                            .{ ._, .v_ps, .movhl, .tmp1x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_sd, .max, .tmp2x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_sd, .cmp, .tmp1x, .tmp1x, .tmp1x, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .tmp2x, .tmp1x },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_f64, .kind = .{ .reg = .xmm0 } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._pd, .mova, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._pd, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._pd, .mova, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, ._pd, .max, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, ._pd, .cmp, .tmp1x, .tmp1x, .sp(.ord), ._ },
                            .{ ._, ._pd, .blendv, .dst0x, .tmp2x, .tmp1x, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, ._pd, .mova, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, ._sd, .max, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, ._sd, .cmp, .tmp1x, .tmp1x, .sp(.ord), ._ },
                            .{ ._, ._pd, .blendv, .dst0x, .tmp2x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._pd, .mova, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._pd, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._pd, .mova, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, ._pd, .max, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, ._pd, .cmp, .tmp1x, .tmp1x, .sp(.unord), ._ },
                            .{ ._, ._pd, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, ._pd, .andn, .tmp1x, .tmp2x, ._, ._ },
                            .{ ._, ._pd, .@"or", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._pd, .xor, .tmp1x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, ._pd, .mova, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, ._sd, .max, .tmp2x, .tmp1x, ._, ._ },
                            .{ ._, ._sd, .cmp, .tmp1x, .tmp1x, .sp(.unord), ._ },
                            .{ ._, ._pd, .@"and", .dst0x, .tmp1x, ._, ._ },
                            .{ ._, ._pd, .andn, .tmp1x, .tmp2x, ._, ._ },
                            .{ ._, ._pd, .@"or", .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .zword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_f64, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = -nan } } },
                            .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_pd, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_pd, .mova, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_pd, .@"and", .tmp3y, .tmp3y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_pd, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                            .{ ._, .v_pd, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_pd, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, .v_pd, .max, .tmp4y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_pd, .cmp, .tmp3y, .tmp3y, .tmp3y, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0y, .dst0y, .tmp4y, .tmp3y },
                            .{ ._, ._, .mov, .tmp0d, .sia(-96, .src0, .add_size), ._, ._ },
                            .{ .@"0:", .v_pd, .mova, .tmp3y, .memi(.src0y, .tmp0), ._, ._ },
                            .{ ._, .v_pd, .max, .tmp4y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_pd, .cmp, .tmp3y, .tmp3y, .tmp3y, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0y, .dst0y, .tmp4y, .tmp3y },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_pd, .max, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_pd, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, .v_ps, .movhl, .tmp3x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_sd, .max, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_sd, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_f64, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = -nan } } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_pd, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_pd, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_pd, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_pd, .max, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_pd, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ .@"0:", .v_pd, .mova, .tmp3x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .v_pd, .max, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_pd, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_ps, .movhl, .tmp3x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_sd, .max, .tmp4x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_sd, .cmp, .tmp3x, .tmp3x, .tmp3x, .vp(.ord) },
                            .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .tmp4x, .tmp3x },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_2_f64, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = -nan } } },
                            .{ .type = .vector_2_f64, .kind = .{ .reg = .xmm0 } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._pd, .mova, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, ._pd, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, ._pd, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ .@"0:", ._pd, .mova, .tmp3x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._pd, .mova, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, ._pd, .max, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, ._pd, .cmp, .tmp3x, .tmp3x, .sp(.ord), ._ },
                            .{ ._, ._pd, .blendv, .dst0x, .tmp4x, .tmp3x, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._ps, .xor, .tmp3x, .tmp3x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp3x, .dst0x, ._, ._ },
                            .{ ._, ._pd, .mova, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, ._sd, .max, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, ._sd, .cmp, .tmp3x, .tmp3x, .sp(.ord), ._ },
                            .{ ._, ._pd, .blendv, .dst0x, .tmp4x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_2_f64, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = -nan } } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._pd, .mova, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, ._pd, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, ._pd, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ .@"0:", ._pd, .mova, .tmp3x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._pd, .mova, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, ._pd, .max, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, ._pd, .cmp, .tmp3x, .tmp3x, .sp(.unord), ._ },
                            .{ ._, ._pd, .@"and", .dst0x, .tmp3x, ._, ._ },
                            .{ ._, ._pd, .andn, .tmp3x, .tmp4x, ._, ._ },
                            .{ ._, ._pd, .@"or", .dst0x, .tmp3x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._ps, .xor, .tmp3x, .tmp3x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp3x, .dst0x, ._, ._ },
                            .{ ._, ._pd, .mova, .tmp4x, .dst0x, ._, ._ },
                            .{ ._, ._sd, .max, .tmp4x, .tmp3x, ._, ._ },
                            .{ ._, ._sd, .cmp, .tmp3x, .tmp3x, .sp(.unord), ._ },
                            .{ ._, ._pd, .@"and", .dst0x, .tmp3x, ._, ._ },
                            .{ ._, ._pd, .andn, .tmp3x, .tmp4x, ._, ._ },
                            .{ ._, ._pd, .@"or", .dst0x, .tmp3x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .x87, .cmov, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f64, .kind = .{ .reg = .st7 } },
                            .{ .type = .f64, .kind = .{ .reg = .st6 } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .f_, .ld, .memad(.src0q, .add_unaligned_size, -8), ._, ._, ._ },
                            .{ .@"0:", .f_, .ld, .memi(.src0q, .tmp0), ._, ._, ._ },
                            .{ ._, .f_, .ucomi, .tmp2t, .tmp2t, ._, ._ },
                            .{ ._, .f_u, .cmov, .tmp2t, .tmp1t, ._, ._ },
                            .{ ._, .f_, .xch, .tmp1t, ._, ._, ._ },
                            .{ ._, .f_, .ucomi, .tmp2t, .tmp1t, ._, ._ },
                            .{ ._, .f_, .xch, .tmp1t, ._, ._, ._ },
                            .{ ._, .f_nb, .cmov, .tmp2t, .tmp1t, ._, ._ },
                            .{ ._, .f_p, .st, .tmp1t, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sahf, .x87, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f64, .kind = .{ .reg = .st7 } },
                            .{ .type = .f64, .kind = .{ .reg = .st6 } },
                            .{ .type = .u16, .kind = .{ .reg = .ax } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .f_, .ld, .memad(.src0q, .add_unaligned_size, -8), ._, ._, ._ },
                            .{ .@"0:", .f_, .ld, .memi(.src0q, .tmp0), ._, ._, ._ },
                            .{ ._, .f_, .ucom, .tmp1t, ._, ._, ._ },
                            .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ },
                            .{ ._, ._, .sahf, ._, ._, ._, ._ },
                            .{ ._, ._nb, .j, .@"1f", ._, ._, ._ },
                            .{ ._, .f_, .xch, .tmp1t, ._, ._, ._ },
                            .{ ._, .f_, .xam, ._, ._, ._, ._ },
                            .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ },
                            .{ ._, ._, .@"test", .tmp3h, .si(0b1_000_100), ._, ._ },
                            .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                            .{ ._, .f_, .xch, .tmp1t, ._, ._, ._ },
                            .{ .@"1:", .f_p, .st, .tmp1t, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .x87, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f64, .kind = .{ .reg = .st7 } },
                            .{ .type = .f64, .kind = .{ .reg = .st6 } },
                            .{ .type = .u16, .kind = .{ .reg = .ax } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .f_, .ld, .memad(.src0q, .add_unaligned_size, -8), ._, ._, ._ },
                            .{ .@"0:", .f_, .ld, .memi(.src0q, .tmp0), ._, ._, ._ },
                            .{ ._, .f_, .ucom, .tmp1t, ._, ._, ._ },
                            .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ },
                            .{ ._, ._, .@"test", .tmp3h, .si(0b0_000_001), ._, ._ },
                            .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                            .{ ._, .f_, .xch, .tmp1t, ._, ._, ._ },
                            .{ ._, .f_, .xam, ._, ._, ._, ._ },
                            .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ },
                            .{ ._, ._, .@"test", .tmp3h, .si(0b1_000_100), ._, ._ },
                            .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                            .{ ._, .f_, .xch, .tmp1t, ._, ._, ._ },
                            .{ .@"1:", .f_p, .st, .tmp1t, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .x87, .cmov, null, null },
                        .dst_constraints = .{ .{ .float = .tbyte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f80, .kind = .{ .reg = .st7 } },
                            .{ .type = .f80, .kind = .{ .reg = .st6 } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .x87 }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .f_, .ld, .memad(.src0t, .add_unaligned_size, -16), ._, ._, ._ },
                            .{ .@"0:", .f_, .ld, .memi(.src0t, .tmp0), ._, ._, ._ },
                            .{ ._, .f_, .ucomi, .tmp2t, .tmp2t, ._, ._ },
                            .{ ._, .f_u, .cmov, .tmp2t, .tmp1t, ._, ._ },
                            .{ ._, .f_, .xch, .tmp1t, ._, ._, ._ },
                            .{ ._, .f_, .ucomi, .tmp2t, .tmp1t, ._, ._ },
                            .{ ._, .f_, .xch, .tmp1t, ._, ._, ._ },
                            .{ ._, .f_nb, .cmov, .tmp2t, .tmp1t, ._, ._ },
                            .{ ._, .f_p, .st, .tmp1t, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sahf, .x87, null, null },
                        .dst_constraints = .{ .{ .float = .tbyte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f80, .kind = .{ .reg = .st7 } },
                            .{ .type = .f80, .kind = .{ .reg = .st6 } },
                            .{ .type = .u16, .kind = .{ .reg = .ax } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .x87 }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .f_, .ld, .memad(.src0t, .add_unaligned_size, -16), ._, ._, ._ },
                            .{ .@"0:", .f_, .ld, .memi(.src0t, .tmp0), ._, ._, ._ },
                            .{ ._, .f_, .ucom, .tmp1t, ._, ._, ._ },
                            .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ },
                            .{ ._, ._, .sahf, ._, ._, ._, ._ },
                            .{ ._, ._nb, .j, .@"1f", ._, ._, ._ },
                            .{ ._, .f_, .xch, .tmp1t, ._, ._, ._ },
                            .{ ._, .f_, .xam, ._, ._, ._, ._ },
                            .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ },
                            .{ ._, ._, .@"test", .tmp3h, .si(0b1_000_100), ._, ._ },
                            .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                            .{ ._, .f_, .xch, .tmp1t, ._, ._, ._ },
                            .{ .@"1:", .f_p, .st, .tmp1t, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .x87, null, null, null },
                        .dst_constraints = .{ .{ .float = .tbyte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f80, .kind = .{ .reg = .st7 } },
                            .{ .type = .f80, .kind = .{ .reg = .st6 } },
                            .{ .type = .u16, .kind = .{ .reg = .ax } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .x87 }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .f_, .ld, .memad(.src0t, .add_unaligned_size, -16), ._, ._, ._ },
                            .{ .@"0:", .f_, .ld, .memi(.src0t, .tmp0), ._, ._, ._ },
                            .{ ._, .f_, .ucom, .tmp1t, ._, ._, ._ },
                            .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ },
                            .{ ._, ._, .@"test", .tmp3h, .si(0b0_000_001), ._, ._ },
                            .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                            .{ ._, .f_, .xch, .tmp1t, ._, ._, ._ },
                            .{ ._, .f_, .xam, ._, ._, ._, ._ },
                            .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ },
                            .{ ._, ._, .@"test", .tmp3h, .si(0b1_000_100), ._, ._ },
                            .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                            .{ ._, .f_, .xch, .tmp1t, ._, ._, ._ },
                            .{ .@"1:", .f_p, .st, .tmp1t, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "fmaxq" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "fmaxq" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "fmaxq" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._ps, .mova, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "fmaxq" } },
                            .{ .type = .f128, .kind = .mem },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp2p, .memi(.src0, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.tmp4), ._, ._ },
                            .{ ._, .v_dqa, .mov, .lea(.tmp1x), .dst0x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "fmaxq" } },
                            .{ .type = .f128, .kind = .mem },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp2p, .memi(.src0, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.tmp4), ._, ._ },
                            .{ ._, ._dqa, .mov, .lea(.tmp1x), .dst0x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "fmaxq" } },
                            .{ .type = .f128, .kind = .mem },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp2p, .memi(.src0, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.tmp4), ._, ._ },
                            .{ ._, ._ps, .mova, .lea(.tmp1x), .dst0x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    } },
                    .Add => comptime &.{ .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .word, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .srl, .tmp0x, .src0x, .ui(8), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .src0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .word, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._dqa, .mov, .tmp0x, .src0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .add, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .add, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp0x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .add, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .add, .tmp0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .srl, .dst0x, .src0x, .ui(8), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .tmp0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .add, .tmp0x, .src0x, ._, ._ },
                            .{ ._, .p_w, .srl, .dst0x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .add, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .add, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .add, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp0x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .add, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .add, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .add, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp2x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .add, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .add, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .add, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .add, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp0x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .add, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .add, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .add, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .add, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp2x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .add, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_i128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .zword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .vp_b, .add, .dst0y, .dst0y, .memd(.src0y, 32), ._ },
                            .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .zword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp2y, .memd(.src0y, 32), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .vp_, .@"and", .tmp2y, .tmp2y, .lead(.tmp0y, 32), ._ },
                            .{ ._, .vp_b, .add, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                            .{ .@"0:", .vp_b, .add, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .srl, .tmp1x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .vp_b, .add, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .srl, .tmp1x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .p_b, .add, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .add, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .add, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .add, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp1x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .add, .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .zword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp2y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ },
                            .{ ._, .vp_, .@"and", .tmp2y, .tmp2y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                            .{ .@"0:", .vp_b, .add, .tmp2y, .tmp2y, .memid(.src0y, .tmp0, 32), ._ },
                            .{ ._, .vp_b, .add, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_b, .add, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ .@"0:", .vp_b, .add, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ .@"0:", .vp_b, .add, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ .@"0:", .p_b, .add, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .add, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_b, .add, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_b, .add, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp2x, .ui(8), ._, ._ },
                            .{ ._, .p_b, .add, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .slow_incdec, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .movzx, .dst0d, .memad(.src0b, .add_unaligned_size, -1), ._, ._ },
                            .{ .@"0:", ._, .add, .dst0b, .memi(.src0b, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .movzx, .dst0d, .memad(.src0b, .add_unaligned_size, -1), ._, ._ },
                            .{ .@"0:", ._, .add, .dst0b, .memi(.src0b, .tmp0), ._, ._ },
                            .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                            .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vph_w, .add, .dst0x, .src0x, .src0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .src0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .ssse3, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .ph_w, .add, .dst0x, .src0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .add, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vph_w, .add, .dst0x, .src0x, .src0x, ._ },
                            .{ ._, .vph_w, .add, .dst0x, .dst0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .ssse3, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .ph_w, .add, .dst0x, .src0x, ._, ._ },
                            .{ ._, .ph_w, .add, .dst0x, .dst0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .add, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .add, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vph_w, .add, .tmp0x, .src0x, .src0x, ._ },
                            .{ ._, .vp_w, .shufl, .dst0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .tmp0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .add, .tmp0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .dst0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .tmp0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .ssse3, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .ph_w, .add, .dst0x, .src0x, ._, ._ },
                            .{ ._, .p_w, .add, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .add, .tmp0x, .src0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .dst0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .add, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vph_w, .add, .dst0x, .src0x, .src0x, ._ },
                            .{ ._, .vph_w, .add, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, .vph_w, .add, .dst0x, .dst0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .ssse3, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .ph_w, .add, .dst0x, .src0x, ._, ._ },
                            .{ ._, .ph_w, .add, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .ph_w, .add, .dst0x, .dst0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .add, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .add, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .add, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ },
                            .{ ._, .vph_w, .add, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, .vph_w, .add, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, .vph_w, .add, .dst0x, .dst0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .ssse3, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, .ph_w, .add, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .ph_w, .add, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .ph_w, .add, .dst0x, .dst0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .add, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .add, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .add, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_i128, .extract, .dst0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .src0x, .dst0x, ._ },
                            .{ ._, .vph_w, .add, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, .vph_w, .add, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, .vph_w, .add, .dst0x, .dst0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_i128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .dst0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .src0x, .dst0x, ._ },
                            .{ ._, .vph_w, .add, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, .vph_w, .add, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, .vph_w, .add, .dst0x, .dst0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vph_w, .add, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, .vph_w, .add, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, .vph_w, .add, .dst0x, .dst0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vph_w, .add, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, .vph_w, .add, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, .vph_w, .add, .dst0x, .dst0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .zword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .vp_w, .add, .dst0y, .dst0y, .memd(.src0y, 32), ._ },
                            .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .zword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp2y, .memd(.src0y, 32), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .vp_, .@"and", .tmp2y, .tmp2y, .lead(.tmp0y, 32), ._ },
                            .{ ._, .vp_w, .add, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                            .{ .@"0:", .vp_w, .add, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vph_w, .add, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, .vph_w, .add, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, .vph_w, .add, .dst0x, .dst0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                            .{ .@"0:", .vp_w, .add, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .vp_w, .add, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vph_w, .add, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vph_w, .add, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, .vph_w, .add, .dst0x, .dst0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .vp_w, .add, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .ssse3, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .p_w, .add, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .ph_w, .add, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .ph_w, .add, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .ph_w, .add, .dst0x, .dst0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .p_w, .add, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .add, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .add, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .add, .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .zword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp2y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ },
                            .{ ._, .vp_, .@"and", .tmp2y, .tmp2y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                            .{ .@"0:", .vp_w, .add, .tmp2y, .tmp2y, .memid(.src0y, .tmp0, 32), ._ },
                            .{ ._, .vp_w, .add, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_w, .add, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ .@"0:", .vp_w, .add, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vph_w, .add, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, .vph_w, .add, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, .vph_w, .add, .dst0x, .dst0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ .@"0:", .vp_w, .add, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ .@"0:", .vp_w, .add, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vph_w, .add, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, .vph_w, .add, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, .vph_w, .add, .dst0x, .dst0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ .@"0:", .vp_w, .add, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .ssse3, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ .@"0:", .p_w, .add, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .ph_w, .add, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .ph_w, .add, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .ph_w, .add, .dst0x, .dst0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ .@"0:", .p_w, .add, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .add, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .add, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .add, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .movzx, .dst0d, .memad(.src0w, .add_unaligned_size, -2), ._, ._ },
                            .{ .@"0:", ._, .add, .dst0w, .memi(.src0w, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vph_d, .add, .dst0x, .src0x, .src0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .src0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .ssse3, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .ph_d, .add, .dst0x, .src0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .add, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vph_d, .add, .dst0x, .src0x, .src0x, ._ },
                            .{ ._, .vph_d, .add, .dst0x, .dst0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .ssse3, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .ph_d, .add, .dst0x, .src0x, ._, ._ },
                            .{ ._, .ph_d, .add, .dst0x, .dst0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .add, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .add, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vph_d, .add, .tmp0x, .src0x, .src0x, ._ },
                            .{ ._, .vp_d, .shuf, .dst0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .tmp0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .add, .tmp0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .dst0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .tmp0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .ssse3, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .ph_d, .add, .dst0x, .src0x, ._, ._ },
                            .{ ._, .p_d, .add, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .add, .tmp0x, .src0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .dst0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .add, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_i128, .extract, .dst0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .src0x, .dst0x, ._ },
                            .{ ._, .vph_d, .add, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, .vph_d, .add, .dst0x, .dst0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_i128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .dst0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .src0x, .dst0x, ._ },
                            .{ ._, .vph_d, .add, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, .vph_d, .add, .dst0x, .dst0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vph_d, .add, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, .vph_d, .add, .dst0x, .dst0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vph_d, .add, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, .vph_d, .add, .dst0x, .dst0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .zword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .vp_d, .add, .dst0y, .dst0y, .memd(.src0y, 32), ._ },
                            .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .zword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp2y, .memd(.src0y, 32), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .vp_, .@"and", .tmp2y, .tmp2y, .lead(.tmp0y, 32), ._ },
                            .{ ._, .vp_d, .add, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                            .{ .@"0:", .vp_d, .add, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vph_d, .add, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, .vph_d, .add, .dst0x, .dst0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                            .{ .@"0:", .vp_d, .add, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .vp_d, .add, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vph_d, .add, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vph_d, .add, .dst0x, .dst0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .vp_d, .add, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .ssse3, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .p_d, .add, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .ph_d, .add, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .ph_d, .add, .dst0x, .dst0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .p_d, .add, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .add, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .add, .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .zword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp2y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ },
                            .{ ._, .vp_, .@"and", .tmp2y, .tmp2y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                            .{ .@"0:", .vp_d, .add, .tmp2y, .tmp2y, .memid(.src0y, .tmp0, 32), ._ },
                            .{ ._, .vp_d, .add, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .add, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ .@"0:", .vp_d, .add, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vph_d, .add, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, .vph_d, .add, .dst0x, .dst0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ .@"0:", .vp_d, .add, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ .@"0:", .vp_d, .add, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vph_d, .add, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, .vph_d, .add, .dst0x, .dst0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ .@"0:", .vp_d, .add, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .ssse3, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ .@"0:", .p_d, .add, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .ph_d, .add, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .ph_d, .add, .dst0x, .dst0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ .@"0:", .p_d, .add, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .add, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_d, .add, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .mov, .dst0d, .memad(.src0d, .add_unaligned_size, -4), ._, ._ },
                            .{ .@"0:", ._, .add, .dst0d, .memi(.src0d, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .qword }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .add, .dst0x, .src0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .qword }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_q, .add, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .int = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_i128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_q, .add, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .add, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_q, .add, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .add, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .int = .qword }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_i128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_q, .add, .tmp0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .dst0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .add, .dst0x, .tmp0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .qword }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_q, .add, .tmp0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .dst0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .add, .dst0x, .tmp0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .int = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .zword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .vp_q, .add, .dst0y, .dst0y, .memd(.src0y, 32), ._ },
                            .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_q, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .add, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .int = .qword }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .zword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp2y, .memd(.src0y, 32), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .vp_, .@"and", .tmp2y, .tmp2y, .lead(.tmp0y, 32), ._ },
                            .{ ._, .vp_q, .add, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_q, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .add, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .int = .qword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                            .{ .@"0:", .vp_q, .add, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_q, .add, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .add, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .qword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .vp_q, .add, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .add, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .qword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .p_q, .add, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_q, .add, .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .int = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .zword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp2y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ },
                            .{ ._, .vp_, .@"and", .tmp2y, .tmp2y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                            .{ .@"0:", .vp_q, .add, .tmp2y, .tmp2y, .memid(.src0y, .tmp0, 32), ._ },
                            .{ ._, .vp_q, .add, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_q, .add, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_q, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .add, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .int = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
                            .{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ .@"0:", .vp_q, .add, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_q, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .add, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_q, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ .@"0:", .vp_q, .add, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_q, .add, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ ._, .p_, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ .@"0:", .p_q, .add, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_q, .add, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .@"64bit", null, null, null },
                        .dst_constraints = .{ .{ .int = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .mov, .dst0q, .memad(.src0q, .add_unaligned_size, -8), ._, ._ },
                            .{ .@"0:", ._, .add, .dst0q, .memi(.src0q, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .@"64bit", null, null, null },
                        .dst_constraints = .{ .{ .remainder_int = .{ .of = .qword, .is = .qword } }, .any },
                        .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u32, .kind = .{ .reg = .rsi } },
                            .{ .type = .usize, .kind = .{ .reg = .rdi } },
                            .{ .type = .u64, .kind = .{ .reg = .rcx } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_unaligned_size_sub_2_elem_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
                            .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_size_div_8), ._, ._ },
                            .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                            .{ .@"0:", ._, .mov, .tmp1p, .sa(.dst0, .sub_size_div_8), ._, ._ },
                            .{ ._, ._, .lea, .tmp2q, .memi(.src0, .tmp0), ._, ._ },
                            .{ ._, ._c, .cl, ._, ._, ._, ._ },
                            .{ .@"1:", ._, .mov, .tmp3q, .leasia(.tmp2q, .@"8", .tmp1, .add_src0_elem_size), ._, ._ },
                            .{ ._, ._, .adc, .memsia(.dst0q, .@"8", .tmp1, .add_size), .tmp3q, ._, ._ },
                            .{ ._, ._c, .in, .tmp1p, ._, ._, ._ },
                            .{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .sa(.dst0, .add_size), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .dword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                            .{ ._, .vh_ps, .add, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .dword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                            .{ ._, .vh_ps, .add, .tmp0x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .shuf, .dst0x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ss, .add, .dst0x, .tmp0x, .dst0x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ss, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, ._, .mov, .tmp0p, .sia(2, .src0, .sub_unaligned_size), ._, ._ },
                            .{ ._, .vp_w, .insr, .dst0x, .dst0x, .mem(.src0w), .ui(0) },
                            .{ .@"0:", .vp_w, .insr, .dst0x, .dst0x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(1) },
                            .{ ._, .v_ps, .cvtph2, .dst0x, .dst0q, ._, ._ },
                            .{ ._, .vh_ps, .add, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                            .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, ._, .mov, .tmp0p, .sia(2, .src0, .sub_unaligned_size), ._, ._ },
                            .{ ._, .vp_w, .insr, .dst0x, .dst0x, .mem(.src0w), .ui(0) },
                            .{ .@"0:", .vp_w, .insr, .dst0x, .dst0x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(1) },
                            .{ ._, .v_ps, .cvtph2, .dst0x, .dst0q, ._, ._ },
                            .{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .add, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                            .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, ._, .mov, .tmp0p, .sia(2, .src0, .sub_unaligned_size), ._, ._ },
                            .{ ._, .vp_w, .insr, .dst0x, .dst0x, .mem(.src0w), .ui(0) },
                            .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
                            .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, .p_, .xor, .dst0x, .dst0x, ._, ._ },
                            .{ ._, ._, .mov, .tmp0p, .sia(2, .src0, .sub_unaligned_size), ._, ._ },
                            .{ ._, .p_w, .insr, .dst0x, .mem(.src0w), .ui(0), ._ },
                            .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f16, .kind = .{ .reg = .ax } },
                            .{ .type = .f32, .kind = .mem },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ },
                            .{ ._, ._, .mov, .tmp0p, .sia(2, .src0, .sub_unaligned_size), ._, ._ },
                            .{ ._, ._, .movzx, .tmp1d, .mem(.src0w), ._, ._ },
                            .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                            .{ ._, ._ss, .mov, .dst0x, .mem(.tmp2d), ._, ._ },
                            .{ .@"0:", ._ps, .xor, .tmp3x, .tmp3x, ._, ._ },
                            .{ ._, ._ss, .mov, .tmp3x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vh_ps, .add, .dst0x, .src0x, .src0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .shuf, .tmp0x, .src0x, .src0x, .ui(0b01) },
                            .{ ._, .v_ss, .add, .dst0x, .src0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse3, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .h_ps, .add, .dst0x, .src0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .mova, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .tmp0x, .tmp0x, .ui(0b01), ._ },
                            .{ ._, ._ss, .add, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vh_ps, .add, .tmp0x, .src0x, .src0x, ._ },
                            .{ ._, .v_ps, .movhl, .dst0x, .src0x, .src0x, ._ },
                            .{ ._, .v_ss, .add, .dst0x, .tmp0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .movhl, .tmp0x, .src0x, .src0x, ._ },
                            .{ ._, .v_ss, .add, .tmp0x, .src0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .dst0x, .src0x, .src0x, .ui(0b01) },
                            .{ ._, .v_ss, .add, .dst0x, .tmp0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse3, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .xor, .tmp0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp0x, .src0x, ._, ._ },
                            .{ ._, .h_ps, .add, .dst0x, .src0x, ._, ._ },
                            .{ ._, ._ss, .add, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .xor, .tmp0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._ss, .add, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .dst0x, .src0x, .ui(0b01), ._ },
                            .{ ._, ._ss, .add, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sia(4, .src0, .sub_unaligned_size), ._, ._ },
                            .{ ._, .v_ss, .mov, .dst0x, .mem(.src0d), ._, ._ },
                            .{ .@"0:", .v_ss, .add, .dst0x, .dst0x, .memia(.src0d, .tmp0, .add_unaligned_size), ._ },
                            .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sia(4, .src0, .sub_unaligned_size), ._, ._ },
                            .{ ._, ._ss, .mov, .dst0x, .mem(.src0d), ._, ._ },
                            .{ .@"0:", ._ss, .add, .dst0x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vh_pd, .add, .dst0x, .src0x, .src0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .movhl, .tmp0x, .src0x, .src0x, ._ },
                            .{ ._, .v_sd, .add, .dst0x, .src0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse3, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .h_pd, .add, .dst0x, .src0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .xor, .tmp0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._sd, .add, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vh_pd, .add, .tmp0x, .src0x, .src0x, ._ },
                            .{ ._, .v_f128, .extract, .dst0x, .src0y, .ui(1), ._ },
                            .{ ._, .v_sd, .add, .dst0x, .tmp0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .v_sd, .add, .tmp0x, .src0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .movhl, .dst0x, .src0x, .src0x, ._ },
                            .{ ._, .v_sd, .add, .dst0x, .tmp0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sia(8, .src0, .sub_unaligned_size), ._, ._ },
                            .{ ._, .v_sd, .mov, .dst0x, .mem(.src0q), ._, ._ },
                            .{ .@"0:", .v_sd, .add, .dst0x, .dst0x, .memia(.src0q, .tmp0, .add_unaligned_size), ._ },
                            .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sia(8, .src0, .sub_unaligned_size), ._, ._ },
                            .{ ._, ._sd, .mov, .dst0x, .mem(.src0q), ._, ._ },
                            .{ .@"0:", ._sd, .add, .dst0x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .x87, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f64, .kind = .{ .reg = .st7 } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sia(8, .src0, .sub_unaligned_size), ._, ._ },
                            .{ ._, .f_, .ld, .mem(.src0q), ._, ._, ._ },
                            .{ .@"0:", .f_, .add, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
                        } },
                    }, .{
                        .required_abi = .gnu,
                        .required_features = .{ .x87, null, null, null },
                        .dst_constraints = .{ .{ .float = .tbyte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .f80, .kind = .{ .reg = .st7 } },
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f80, .kind = .{ .reg = .st6 } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .x87 }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, .f_, .ld, .mem(.src0t), ._, ._, ._ },
                            .{ ._, ._, .mov, .tmp1p, .sia(16, .src0, .sub_unaligned_size), ._, ._ },
                            .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp1, .add_unaligned_size), ._, ._, ._ },
                            .{ ._, .f_p, .add, ._, ._, ._, ._ },
                            .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                        } },
                    }, .{
                        .required_abi = .msvc,
                        .required_features = .{ .x87, null, null, null },
                        .dst_constraints = .{ .{ .float = .tbyte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .f80, .kind = .{ .reg = .st7 } },
                            .{ .type = .u16, .kind = .mem },
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f80, .kind = .{ .reg = .st6 } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .x87 }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, .f_, .ld, .mem(.src0t), ._, ._, ._ },
                            .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
                            .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
                            .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_00_11), ._, ._ },
                            .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                            .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
                            .{ ._, ._, .mov, .tmp2p, .sia(16, .src0, .sub_unaligned_size), ._, ._ },
                            .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp2, .add_unaligned_size), ._, ._, ._ },
                            .{ ._, .f_p, .add, ._, ._, ._, ._ },
                            .{ ._, ._, .add, .tmp2p, .si(16), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                            .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0x, .mem(.src0x), ._, ._ },
                            .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .mem(.src0x), ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_unaligned_size), ._, ._ },
                            .{ ._, ._ps, .mova, .dst0x, .mem(.src0x), ._, ._ },
                            .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                            .{ .type = .f128, .kind = .mem },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_unaligned_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp2p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.tmp4), ._, ._ },
                            .{ ._, .v_dqa, .mov, .lea(.tmp1x), .dst0x, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                            .{ .type = .f128, .kind = .mem },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_unaligned_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp2p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.tmp4), ._, ._ },
                            .{ ._, ._dqa, .mov, .lea(.tmp1x), .dst0x, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                            .{ .type = .f128, .kind = .mem },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_unaligned_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp2p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.tmp4), ._, ._ },
                            .{ ._, ._ps, .mova, .lea(.tmp1x), .dst0x, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    } },
                    .Mul => comptime &.{ .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .word, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .srl, .tmp0x, .src0x, .ui(8), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .src0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .word, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._dqa, .mov, .tmp0x, .src0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .srl, .tmp0x, .src0x, .ui(8), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._dqa, .mov, .tmp0x, .src0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
                            .{ ._, .p_w, .mull, .tmp0x, .src0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .dst0x, .tmp0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .mull, .tmp0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .srl, .dst0x, .src0x, .ui(8), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .tmp0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .mull, .tmp0x, .src0x, ._, ._ },
                            .{ ._, .p_w, .srl, .dst0x, .ui(8), ._, ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .srl, .tmp0x, .src0x, .ui(8), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._dqa, .mov, .tmp0x, .src0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
                            .{ ._, .p_w, .mull, .tmp0x, .src0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .dst0x, .tmp0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_8_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_q, .mov, .tmp2x, .lea(.tmp0q), ._, ._ },
                            .{ ._, .vp_, .andn, .dst0x, .tmp2x, .src0x, ._ },
                            .{ ._, .vp_b, .sub, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_8_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._q, .mov, .tmp2x, .lea(.tmp0q), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_, .andn, .dst0x, .src0x, ._, ._ },
                            .{ ._, .p_b, .sub, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp2x, .ui(8), ._, ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .srl, .tmp0x, .src0x, .ui(8), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._dqa, .mov, .tmp0x, .src0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
                            .{ ._, .p_w, .mull, .tmp0x, .src0x, ._, ._ },
                            .{ ._, .p_d, .shuf, .dst0x, .tmp0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                            .{ ._, .vp_, .andn, .dst0x, .tmp2x, .src0x, ._ },
                            .{ ._, .vp_b, .sub, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_, .andn, .dst0x, .src0x, ._, ._ },
                            .{ ._, .p_b, .sub, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp2x, .ui(8), ._, ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .srl, .tmp0y, .src0y, .ui(8), ._ },
                            .{ ._, .vp_w, .mull, .dst0y, .src0y, .tmp0y, ._ },
                            .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_w, .srl, .tmp1x, .src0x, .ui(8), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .src0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .srl, .tmp1x, .tmp0x, .ui(8), ._ },
                            .{ ._, .vp_w, .mull, .tmp0x, .tmp0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp2y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .vp_, .andn, .dst0y, .tmp2y, .src0y, ._ },
                            .{ ._, .vp_b, .sub, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .vp_w, .srl, .tmp2y, .dst0y, .ui(8), ._ },
                            .{ ._, .vp_w, .mull, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .tmp2y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_ps, .andn, .tmp3y, .tmp2y, .src0y, ._ },
                            .{ ._, .vp_b, .sub, .dst0x, .tmp3x, .tmp2x, ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .tmp2y, .ui(1), ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .tmp3y, .ui(1), ._ },
                            .{ ._, .vp_b, .sub, .tmp2x, .tmp3x, .tmp2x, ._ },
                            .{ ._, .vp_w, .srl, .tmp3x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .srl, .tmp3x, .tmp2x, .ui(8), ._ },
                            .{ ._, .vp_w, .mull, .tmp2x, .tmp2x, .tmp3x, ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .zword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp0y, .memd(.src0y, 32), ._, ._ },
                            .{ ._, .vp_w, .srl, .tmp1y, .dst0y, .ui(8), ._ },
                            .{ ._, .vp_w, .mull, .dst0y, .dst0y, .tmp1y, ._ },
                            .{ ._, .vp_w, .srl, .tmp1y, .tmp0y, .ui(8), ._ },
                            .{ ._, .vp_w, .mull, .tmp0y, .tmp0y, .tmp1y, ._ },
                            .{ ._, .vp_w, .mull, .dst0y, .dst0y, .tmp0y, ._ },
                            .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .zword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp2y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, .vp_, .andn, .tmp3y, .tmp2y, .memd(.src0y, 32), ._ },
                            .{ ._, .vp_b, .sub, .tmp2y, .tmp3y, .tmp2y, ._ },
                            .{ ._, .vp_, .andn, .tmp3y, .dst0y, .mem(.src0y), ._ },
                            .{ ._, .vp_b, .sub, .dst0y, .tmp3y, .dst0y, ._ },
                            .{ ._, .vp_w, .srl, .tmp3y, .tmp2y, .ui(8), ._ },
                            .{ ._, .vp_w, .mull, .tmp2y, .tmp2y, .tmp3y, ._ },
                            .{ ._, .vp_w, .srl, .tmp3y, .dst0y, .ui(8), ._ },
                            .{ ._, .vp_w, .mull, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ ._, .vp_w, .mull, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                            .{ ._, .vp_w, .srl, .tmp1y, .dst0y, .ui(8), ._ },
                            .{ ._, .vp_w, .mull, .dst0y, .dst0y, .tmp1y, ._ },
                            .{ .@"0:", .vp_w, .movzxb, .tmp1y, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .vp_w, .mull, .dst0y, .dst0y, .tmp1y, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-24, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ ._, .vp_w, .srl, .tmp1x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ .@"0:", .vp_w, .movzxb, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-24, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp1x, .ui(8), ._, ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp1x, ._, ._ },
                            .{ .@"0:", .p_w, .movzxb, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-24, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp1x, .ui(8), ._, ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp1x, ._, ._ },
                            .{ .@"0:", ._q, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                            .{ ._, .p_, .unpcklbw, .tmp1x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .zword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp2y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-96, .src0, .add_size), ._, ._ },
                            .{ ._, .vp_, .andn, .tmp3y, .tmp2y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .vp_b, .sub, .tmp2y, .tmp3y, .tmp2y, ._ },
                            .{ ._, .vp_, .andn, .tmp3y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                            .{ ._, .vp_b, .sub, .dst0y, .tmp3y, .dst0y, ._ },
                            .{ ._, .vp_w, .srl, .tmp3y, .tmp2y, .ui(8), ._ },
                            .{ ._, .vp_w, .mull, .tmp2y, .tmp2y, .tmp3y, ._ },
                            .{ ._, .vp_w, .srl, .tmp3y, .dst0y, .ui(8), ._ },
                            .{ ._, .vp_w, .mull, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ .@"0:", .vp_w, .movzxb, .tmp3y, .memid(.src0x, .tmp0, 16), ._, ._ },
                            .{ ._, .vp_w, .mull, .tmp2y, .tmp2y, .tmp3y, ._ },
                            .{ ._, .vp_w, .movzxb, .tmp3y, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .vp_w, .mull, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_w, .mull, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp2y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .vp_, .andn, .dst0y, .tmp2y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .vp_b, .sub, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .vp_w, .srl, .tmp2y, .dst0y, .ui(8), ._ },
                            .{ ._, .vp_w, .mull, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ .@"0:", .vp_w, .movzxb, .tmp2y, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .vp_w, .mull, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .tmp2y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-40, .src0, .add_size), ._, ._ },
                            .{ ._, .v_ps, .andn, .tmp3y, .tmp2y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .vp_b, .sub, .dst0x, .tmp3x, .tmp2x, ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .tmp2y, .ui(1), ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .tmp3y, .ui(1), ._ },
                            .{ ._, .vp_b, .sub, .tmp2x, .tmp3x, .tmp2x, ._ },
                            .{ ._, .vp_w, .srl, .tmp3x, .dst0x, .ui(8), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .vp_w, .srl, .tmp3x, .tmp2x, .ui(8), ._ },
                            .{ ._, .vp_w, .mull, .tmp2x, .tmp2x, .tmp3x, ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ .@"0:", .vp_w, .movzxb, .tmp2x, .memi(.src0q, .tmp0), ._, ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-24, .src0, .add_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_, .andn, .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, .p_b, .sub, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp2x, .ui(8), ._, ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp2x, ._, ._ },
                            .{ .@"0:", .p_w, .movzxb, .tmp2x, .memi(.src0q, .tmp0), ._, ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-24, .src0, .add_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_, .andn, .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, .p_b, .sub, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, .p_w, .srl, .tmp2x, .ui(8), ._, ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp2x, ._, ._ },
                            .{ .@"0:", ._q, .mov, .tmp2x, .memi(.src0q, .tmp0), ._, ._ },
                            .{ ._, .p_, .unpcklbw, .tmp2x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .slow_incdec, null, null, null },
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .reg = .al }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .movzx, .dst0d, .memad(.src0b, .add_unaligned_size, -1), ._, ._ },
                            .{ .@"0:", ._, .mul, .memi(.src0b, .tmp0), ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .dst_constraints = .{ .{ .int = .byte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .reg = .al }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .movzx, .dst0d, .memad(.src0b, .add_unaligned_size, -1), ._, ._ },
                            .{ .@"0:", ._, .mul, .memi(.src0b, .tmp0), ._, ._, ._ },
                            .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                            .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .src0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .tmp0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .dst0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .tmp0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .mull, .tmp0x, .src0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .dst0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                            .{ ._, .vp_, .andn, .dst0x, .tmp2x, .src0x, ._ },
                            .{ ._, .vp_w, .sub, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_, .andn, .dst0x, .src0x, ._, ._ },
                            .{ ._, .p_w, .sub, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_i128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp2y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .vp_, .andn, .dst0y, .tmp2y, .src0y, ._ },
                            .{ ._, .vp_w, .sub, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .tmp2y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_ps, .andn, .tmp3y, .tmp2y, .src0y, ._ },
                            .{ ._, .vp_w, .sub, .dst0x, .tmp3x, .tmp2x, ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .tmp2y, .ui(1), ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .tmp3y, .ui(1), ._ },
                            .{ ._, .vp_w, .sub, .tmp2x, .tmp3x, .tmp2x, ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .zword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .vp_w, .mull, .dst0y, .dst0y, .memd(.src0y, 32), ._ },
                            .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp0x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .zword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp2y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, .vp_, .andn, .tmp3y, .tmp2y, .memd(.src0y, 32), ._ },
                            .{ ._, .vp_w, .sub, .tmp2y, .tmp3y, .tmp2y, ._ },
                            .{ ._, .vp_, .andn, .tmp3y, .dst0y, .mem(.src0y), ._ },
                            .{ ._, .vp_w, .sub, .dst0y, .tmp3y, .dst0y, ._ },
                            .{ ._, .vp_w, .mull, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                            .{ .@"0:", .vp_w, .mull, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .vp_w, .mull, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp1x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .p_w, .mull, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp1x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .zword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp2y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ },
                            .{ ._, .vp_, .andn, .tmp3y, .tmp2y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .vp_w, .sub, .tmp2y, .tmp3y, .tmp2y, ._ },
                            .{ ._, .vp_, .andn, .tmp3y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                            .{ ._, .vp_w, .sub, .dst0y, .tmp3y, .dst0y, ._ },
                            .{ .@"0:", .vp_w, .mull, .tmp2y, .tmp2y, .memid(.src0y, .tmp0, 32), ._ },
                            .{ ._, .vp_w, .mull, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_w, .mull, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp2y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
                            .{ ._, .vp_, .andn, .dst0y, .tmp2y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .vp_w, .sub, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ .@"0:", .vp_w, .mull, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .tmp2y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_ps, .andn, .tmp3y, .tmp2y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .vp_w, .sub, .dst0x, .tmp3x, .tmp2x, ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .tmp2y, .ui(1), ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .tmp3y, .ui(1), ._ },
                            .{ ._, .vp_w, .sub, .tmp2x, .tmp3x, .tmp2x, ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ .@"0:", .vp_w, .mull, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_, .andn, .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, .p_w, .sub, .dst0x, .tmp2x, ._, ._ },
                            .{ .@"0:", .p_w, .mull, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_w, .shufl, .tmp2x, .dst0x, .ui(0b01), ._ },
                            .{ ._, .p_w, .mull, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .dst_constraints = .{ .{ .int = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .movzx, .dst0d, .memad(.src0w, .add_unaligned_size, -2), ._, ._ },
                            .{ .@"0:", .i_, .mul, .dst0w, .memi(.src0w, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b01), ._ },
                            .{ ._, .vp_udq, .mul, .dst0x, .src0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_w, .shufl, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_udq, .mul, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_11_01_01), ._ },
                            .{ ._, .vp_udq, .mul, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_udq, .mul, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_11_01_01), ._ },
                            .{ ._, .p_udq, .mul, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_udq, .mul, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_udq, .mul, .tmp0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_w, .shufl, .dst0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_udq, .mul, .dst0x, .tmp0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_udq, .mul, .tmp0x, .src0x, ._, ._ },
                            .{ ._, .p_w, .shufl, .dst0x, .src0x, .ui(0b11_10), ._ },
                            .{ ._, .p_udq, .mul, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_i128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_d, .mull, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_11_01_01), ._ },
                            .{ ._, .vp_udq, .mul, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_udq, .mul, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .vp_d, .mull, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_11_01_01), ._ },
                            .{ ._, .vp_udq, .mul, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_udq, .mul, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp2y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .vp_, .andn, .dst0y, .tmp2y, .src0y, ._ },
                            .{ ._, .vp_d, .sub, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_11_01_01), ._ },
                            .{ ._, .vp_udq, .mul, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_udq, .mul, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .tmp2y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_ps, .andn, .tmp3y, .tmp2y, .src0y, ._ },
                            .{ ._, .vp_d, .sub, .dst0x, .tmp3x, .tmp2x, ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .tmp2y, .ui(1), ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .tmp3y, .ui(1), ._ },
                            .{ ._, .vp_d, .sub, .tmp2x, .tmp3x, .tmp2x, ._ },
                            .{ ._, .vp_d, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_11_01_01), ._ },
                            .{ ._, .vp_udq, .mul, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_udq, .mul, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .zword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .vp_d, .mull, .dst0y, .dst0y, .memd(.src0y, 32), ._ },
                            .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .mull, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_11_01_01), ._ },
                            .{ ._, .vp_udq, .mul, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_udq, .mul, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .scalar_int = .{ .of = .zword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp2y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, .vp_, .andn, .tmp3y, .tmp2y, .memd(.src0y, 32), ._ },
                            .{ ._, .vp_d, .sub, .tmp2y, .tmp3y, .tmp2y, ._ },
                            .{ ._, .vp_, .andn, .tmp3y, .dst0y, .mem(.src0y), ._ },
                            .{ ._, .vp_d, .sub, .dst0y, .tmp3y, .dst0y, ._ },
                            .{ ._, .vp_d, .mull, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_11_01_01), ._ },
                            .{ ._, .vp_udq, .mul, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_udq, .mul, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                            .{ .@"0:", .vp_d, .mull, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .mull, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_11_01_01), ._ },
                            .{ ._, .vp_udq, .mul, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_udq, .mul, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .vp_d, .mull, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_11_01_01), ._ },
                            .{ ._, .vp_udq, .mul, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_udq, .mul, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .p_d, .mull, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_11_01_01), ._ },
                            .{ ._, .p_udq, .mul, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_udq, .mul, .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_11_01_01), ._ },
                            .{ ._, .p_udq, .mul, .dst0x, .tmp1x, ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .p_udq, .mul, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp1x, .tmp1x, .ui(0b11_11_01_01), ._ },
                            .{ ._, .p_udq, .mul, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_udq, .mul, .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .zword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp2y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ },
                            .{ ._, .vp_, .andn, .tmp3y, .tmp2y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .vp_d, .sub, .tmp2y, .tmp3y, .tmp2y, ._ },
                            .{ ._, .vp_, .andn, .tmp3y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                            .{ ._, .vp_d, .sub, .dst0y, .tmp3y, .dst0y, ._ },
                            .{ .@"0:", .vp_d, .mull, .tmp2y, .tmp2y, .memid(.src0y, .tmp0, 32), ._ },
                            .{ ._, .vp_d, .mull, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .mull, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_11_01_01), ._ },
                            .{ ._, .vp_udq, .mul, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_udq, .mul, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx2, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_dqa, .mov, .tmp2y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
                            .{ ._, .vp_, .andn, .dst0y, .tmp2y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .vp_d, .sub, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ .@"0:", .vp_d, .mull, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .vp_d, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_11_01_01), ._ },
                            .{ ._, .vp_udq, .mul, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_udq, .mul, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .tmp2y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_ps, .andn, .tmp3y, .tmp2y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .vp_d, .sub, .dst0x, .tmp3x, .tmp2x, ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .tmp2y, .ui(1), ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .tmp3y, .ui(1), ._ },
                            .{ ._, .vp_d, .sub, .tmp2x, .tmp3x, .tmp2x, ._ },
                            .{ ._, .vp_d, .mull, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ .@"0:", .vp_d, .mull, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_11_01_01), ._ },
                            .{ ._, .vp_udq, .mul, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .vp_udq, .mul, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse4_1, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_, .andn, .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, .p_d, .sub, .dst0x, .tmp2x, ._, ._ },
                            .{ .@"0:", .p_d, .mull, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_11_01_01), ._ },
                            .{ ._, .p_udq, .mul, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_udq, .mul, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0, .invert = true } } },
                            .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_, .andn, .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, .p_d, .sub, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_11_01_01), ._ },
                            .{ ._, .p_udq, .mul, .dst0x, .tmp2x, ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp2x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .p_udq, .mul, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp2x, .tmp2x, .ui(0b11_11_01_01), ._ },
                            .{ ._, .p_udq, .mul, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10), ._ },
                            .{ ._, .p_udq, .mul, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .dst_constraints = .{ .{ .int = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .mov, .dst0d, .memad(.src0d, .add_unaligned_size, -4), ._, ._ },
                            .{ .@"0:", .i_, .mul, .dst0d, .memi(.src0d, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .@"64bit", null, null, null },
                        .dst_constraints = .{ .{ .int = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .general_purpose }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .mov, .dst0q, .memad(.src0q, .add_unaligned_size, -8), ._, ._ },
                            .{ .@"0:", .i_, .mul, .dst0q, .memi(.src0q, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .@"64bit", .bmi2, .adx, null },
                        .dst_constraints = .{ .{ .remainder_int = .{ .of = .qword, .is = .qword } }, .any },
                        .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u64, .kind = .{ .reg = .rdx } },
                            .{ .type = .isize, .kind = .{ .reg = .rcx } },
                            .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_unaligned_size_sub_2_elem_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp2p, .memi(.src0, .tmp0), ._, ._ },
                            .{ ._, ._, .mov, .tmp3d, .sia(-8, .dst0, .add_size), ._, ._ },
                            .{ .@"1:", ._, .xor, .tmp4d, .tmp4d, ._, ._ },
                            .{ ._, ._, .@"or", .tmp4q, .leai(.tmp1q, .tmp3), ._, ._ },
                            .{ ._, ._z, .j, .@"3f", ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp5p, .leaad(.tmp3, .sub_src0_elem_size, 8), ._, ._ },
                            .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                            .{ .@"2:", ._x, .mul, .tmp8q, .tmp7q, .leai(.tmp2q, .tmp5), ._ },
                            .{ ._, ._x, .adc, .tmp7q, .tmp6q, ._, ._ },
                            .{ ._, ._, .mov, .memiad(.dst0q, .tmp5, .add_src0_elem_size, -8), .tmp7q, ._, ._ },
                            .{ ._, ._rcxz, .j, .@"2f", ._, ._, ._ },
                            .{ ._, ._x, .ado, .tmp8q, .memia(.dst0q, .tmp5, .add_src0_elem_size), ._, ._ },
                            .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ },
                            .{ ._, ._, .lea, .tmp5p, .lead(.tmp5, 8), ._, ._ },
                            .{ ._, ._mp, .j, .@"2b", ._, ._, ._ },
                            .{ .@"3:", ._, .mov, .memi(.dst0q, .tmp3), .tmp4q, ._, ._ },
                            .{ .@"2:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                            .{ ._, ._, .sub, .tmp3d, .si(8), ._, ._ },
                            .{ ._, ._ae, .j, .@"1b", ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .sa(.dst0, .add_size), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .@"64bit", .bmi2, .slow_incdec, null },
                        .dst_constraints = .{ .{ .remainder_int = .{ .of = .qword, .is = .qword } }, .any },
                        .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u64, .kind = .{ .reg = .rdx } },
                            .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(8, .src0, .add_unaligned_size_sub_2_elem_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp2p, .memi(.src0, .tmp0), ._, ._ },
                            .{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                            .{ .@"1:", ._, .lea, .tmp4p, .leaa(.tmp3, .sub_src0_elem_size_div_8), ._, ._ },
                            .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                            .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                            .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                            .{ ._, ._, .@"or", .tmp5q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ },
                            .{ ._, ._nz, .j, .@"3f", ._, ._, ._ },
                            .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp3), .tmp5q, ._, ._ },
                            .{ ._, ._mp, .j, .@"4f", ._, ._, ._ },
                            .{ .@"2:", ._, .adc, .tmp9q, .memsia(.dst0q, .@"8", .tmp4, .add_src0_elem_size), ._, ._ },
                            .{ ._, ._, .adc, .tmp6b, .si(0), ._, ._ },
                            .{ ._, ._, .mov, .tmp7q, .tmp9q, ._, ._ },
                            .{ ._, ._l, .sh, .tmp6b, .ui(4), ._, ._ },
                            .{ .@"3:", ._x, .mul, .tmp9q, .tmp8q, .leasi(.tmp2q, .@"8", .tmp4), ._ },
                            .{ ._, ._, .adc, .tmp8q, .tmp7q, ._, ._ },
                            .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp4, .add_src0_elem_size), .tmp8q, ._, ._ },
                            .{ ._, ._c, .in, .tmp4p, ._, ._, ._ },
                            .{ ._, ._nz, .j, .@"2b", ._, ._, ._ },
                            .{ .@"4:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                            .{ ._, ._, .sub, .tmp3d, .si(1), ._, ._ },
                            .{ ._, ._ae, .j, .@"1b", ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .sa(.dst0, .add_size), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .@"64bit", .bmi2, null, null },
                        .dst_constraints = .{ .{ .remainder_int = .{ .of = .qword, .is = .qword } }, .any },
                        .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u64, .kind = .{ .reg = .rdx } },
                            .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(8, .src0, .add_unaligned_size_sub_2_elem_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp2p, .memi(.src0, .tmp0), ._, ._ },
                            .{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                            .{ .@"1:", ._, .lea, .tmp4p, .leaa(.tmp3, .sub_src0_elem_size_div_8), ._, ._ },
                            .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                            .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                            .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                            .{ ._, ._, .@"or", .tmp5q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ },
                            .{ ._, ._nz, .j, .@"3f", ._, ._, ._ },
                            .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp3), .tmp5q, ._, ._ },
                            .{ ._, ._mp, .j, .@"4f", ._, ._, ._ },
                            .{ .@"2:", ._, .adc, .tmp9q, .memsia(.dst0q, .@"8", .tmp4, .add_src0_elem_size), ._, ._ },
                            .{ ._, ._, .adc, .tmp6b, .si(0), ._, ._ },
                            .{ ._, ._, .mov, .tmp7q, .tmp9q, ._, ._ },
                            .{ ._, ._l, .sh, .tmp6b, .ui(4), ._, ._ },
                            .{ .@"3:", ._x, .mul, .tmp9q, .tmp8q, .leasi(.tmp2q, .@"8", .tmp4), ._ },
                            .{ ._, ._, .adc, .tmp8q, .tmp7q, ._, ._ },
                            .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp4, .add_src0_elem_size), .tmp8q, ._, ._ },
                            .{ ._, ._c, .in, .tmp4p, ._, ._, ._ },
                            .{ ._, ._nz, .j, .@"2b", ._, ._, ._ },
                            .{ .@"4:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                            .{ ._, ._c, .de, .tmp3d, ._, ._, ._ },
                            .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .sa(.dst0, .add_size), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .@"64bit", .slow_incdec, null, null },
                        .dst_constraints = .{ .{ .remainder_int = .{ .of = .qword, .is = .qword } }, .any },
                        .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u64, .kind = .{ .reg = .rax } },
                            .{ .type = .u64, .kind = .{ .reg = .rdx } },
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(8, .src0, .add_unaligned_size_sub_2_elem_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp2p, .memi(.src0, .tmp0), ._, ._ },
                            .{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                            .{ .@"1:", ._, .lea, .tmp4p, .leaa(.tmp3, .sub_src0_elem_size_div_8), ._, ._ },
                            .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                            .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                            .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                            .{ ._, ._, .@"or", .tmp5q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ },
                            .{ ._, ._nz, .j, .@"3f", ._, ._, ._ },
                            .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp3), .tmp5q, ._, ._ },
                            .{ ._, ._mp, .j, .@"4f", ._, ._, ._ },
                            .{ .@"2:", ._, .adc, .tmp9q, .memsia(.dst0q, .@"8", .tmp4, .add_src0_elem_size), ._, ._ },
                            .{ ._, ._, .adc, .tmp6b, .si(0), ._, ._ },
                            .{ ._, ._, .mov, .tmp7q, .tmp9q, ._, ._ },
                            .{ .@"3:", ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                            .{ ._, ._, .mul, .leasi(.tmp2q, .@"8", .tmp4), ._, ._, ._ },
                            .{ ._, ._l, .sh, .tmp6b, .ui(4), ._, ._ },
                            .{ ._, ._, .adc, .tmp8q, .tmp7q, ._, ._ },
                            .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp4, .add_src0_elem_size), .tmp8q, ._, ._ },
                            .{ ._, ._c, .in, .tmp4p, ._, ._, ._ },
                            .{ ._, ._nz, .j, .@"2b", ._, ._, ._ },
                            .{ .@"4:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                            .{ ._, ._, .sub, .tmp3d, .si(1), ._, ._ },
                            .{ ._, ._ae, .j, .@"1b", ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .sa(.dst0, .add_size), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .@"64bit", null, null, null },
                        .dst_constraints = .{ .{ .remainder_int = .{ .of = .qword, .is = .qword } }, .any },
                        .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .u64, .kind = .{ .reg = .rax } },
                            .{ .type = .u64, .kind = .{ .reg = .rdx } },
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(8, .src0, .add_unaligned_size_sub_2_elem_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp2p, .memi(.src0, .tmp0), ._, ._ },
                            .{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
                            .{ .@"1:", ._, .lea, .tmp4p, .leaa(.tmp3, .sub_src0_elem_size_div_8), ._, ._ },
                            .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
                            .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
                            .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
                            .{ ._, ._, .@"or", .tmp5q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ },
                            .{ ._, ._nz, .j, .@"3f", ._, ._, ._ },
                            .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp3), .tmp5q, ._, ._ },
                            .{ ._, ._mp, .j, .@"4f", ._, ._, ._ },
                            .{ .@"2:", ._, .adc, .tmp9q, .memsia(.dst0q, .@"8", .tmp4, .add_src0_elem_size), ._, ._ },
                            .{ ._, ._, .adc, .tmp6b, .si(0), ._, ._ },
                            .{ ._, ._, .mov, .tmp7q, .tmp9q, ._, ._ },
                            .{ .@"3:", ._, .mov, .tmp8q, .tmp5q, ._, ._ },
                            .{ ._, ._, .mul, .leasi(.tmp2q, .@"8", .tmp4), ._, ._, ._ },
                            .{ ._, ._l, .sh, .tmp6b, .ui(4), ._, ._ },
                            .{ ._, ._, .adc, .tmp8q, .tmp7q, ._, ._ },
                            .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp4, .add_src0_elem_size), .tmp8q, ._, ._ },
                            .{ ._, ._c, .in, .tmp4p, ._, ._, ._ },
                            .{ ._, ._nz, .j, .@"2b", ._, ._, ._ },
                            .{ .@"4:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
                            .{ ._, ._c, .de, .tmp3d, ._, ._, ._ },
                            .{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .sa(.dst0, .add_size), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .dword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .mul, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ss, .mul, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .mul, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f16, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, ._, .mov, .tmp0p, .sia(2, .src0, .sub_unaligned_size), ._, ._ },
                            .{ ._, .vp_w, .insr, .dst0x, .dst0x, .mem(.src0w), .ui(0) },
                            .{ .@"0:", .vp_w, .insr, .dst0x, .dst0x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(1) },
                            .{ ._, .v_ps, .cvtph2, .dst0x, .dst0q, ._, ._ },
                            .{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .mul, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                            .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__mulhf3" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, ._, .mov, .tmp0p, .sia(2, .src0, .sub_unaligned_size), ._, ._ },
                            .{ ._, .vp_w, .insr, .dst0x, .dst0x, .mem(.src0w), .ui(0) },
                            .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
                            .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__mulhf3" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, .p_, .xor, .dst0x, .dst0x, ._, ._ },
                            .{ ._, ._, .mov, .tmp0p, .sia(2, .src0, .sub_unaligned_size), ._, ._ },
                            .{ ._, .p_w, .insr, .dst0x, .mem(.src0w), .ui(0), ._ },
                            .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f16, .kind = .{ .reg = .ax } },
                            .{ .type = .f32, .kind = .mem },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__mulhf3" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ },
                            .{ ._, ._, .mov, .tmp0p, .sia(2, .src0, .sub_unaligned_size), ._, ._ },
                            .{ ._, ._, .movzx, .tmp1d, .mem(.src0w), ._, ._ },
                            .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                            .{ ._, ._ss, .mov, .dst0x, .mem(.tmp2d), ._, ._ },
                            .{ .@"0:", ._ps, .xor, .tmp3x, .tmp3x, ._, ._ },
                            .{ ._, ._ss, .mov, .tmp3x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .shuf, .tmp0x, .src0x, .src0x, .ui(0b01) },
                            .{ ._, .v_ss, .mul, .dst0x, .src0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .mova, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .tmp0x, .tmp0x, .ui(0b01), ._ },
                            .{ ._, ._ss, .mul, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .movhl, .tmp0x, .src0x, .src0x, ._ },
                            .{ ._, .v_ss, .mul, .tmp0x, .src0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .dst0x, .src0x, .src0x, .ui(0b01) },
                            .{ ._, .v_ss, .mul, .dst0x, .tmp0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .xor, .tmp0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._ss, .mul, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .dst0x, .src0x, .ui(0b01), ._ },
                            .{ ._, ._ss, .mul, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sia(4, .src0, .sub_unaligned_size), ._, ._ },
                            .{ ._, .v_ss, .mov, .dst0x, .mem(.src0d), ._, ._ },
                            .{ .@"0:", .v_ss, .mul, .dst0x, .dst0x, .memia(.src0d, .tmp0, .add_unaligned_size), ._ },
                            .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sia(4, .src0, .sub_unaligned_size), ._, ._ },
                            .{ ._, ._ss, .mov, .dst0x, .mem(.src0d), ._, ._ },
                            .{ .@"0:", ._ss, .mul, .dst0x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .movhl, .tmp0x, .src0x, .src0x, ._ },
                            .{ ._, .v_sd, .mul, .dst0x, .src0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .xor, .tmp0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._sd, .mul, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .v_sd, .mul, .tmp0x, .src0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .movhl, .dst0x, .src0x, .src0x, ._ },
                            .{ ._, .v_sd, .mul, .dst0x, .tmp0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sia(8, .src0, .sub_unaligned_size), ._, ._ },
                            .{ ._, .v_sd, .mov, .dst0x, .mem(.src0q), ._, ._ },
                            .{ .@"0:", .v_sd, .mul, .dst0x, .dst0x, .memia(.src0q, .tmp0, .add_unaligned_size), ._ },
                            .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sia(8, .src0, .sub_unaligned_size), ._, ._ },
                            .{ ._, ._sd, .mov, .dst0x, .mem(.src0q), ._, ._ },
                            .{ .@"0:", ._sd, .mul, .dst0x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .x87, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f64, .kind = .{ .reg = .st7 } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sia(8, .src0, .sub_unaligned_size), ._, ._ },
                            .{ ._, .f_, .ld, .mem(.src0q), ._, ._, ._ },
                            .{ ._, ._mp, .j, .@"1f", ._, ._, ._ },
                            .{ .pseudo, .f_cstp, .in, ._, ._, ._, ._ },
                            .{ .@"0:", .f_, .ld, .dst0q, ._, ._, ._ },
                            .{ .@"1:", .f_, .mul, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                            .{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_abi = .gnu,
                        .required_features = .{ .x87, null, null, null },
                        .dst_constraints = .{ .{ .float = .tbyte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .f80, .kind = .{ .reg = .st7 } },
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f80, .kind = .{ .reg = .st6 } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .x87 }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, .f_, .ld, .mem(.src0t), ._, ._, ._ },
                            .{ ._, ._, .mov, .tmp1p, .sia(16, .src0, .sub_unaligned_size), ._, ._ },
                            .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp1, .add_unaligned_size), ._, ._, ._ },
                            .{ ._, .f_p, .mul, ._, ._, ._, ._ },
                            .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                        } },
                    }, .{
                        .required_abi = .msvc,
                        .required_features = .{ .x87, null, null, null },
                        .dst_constraints = .{ .{ .float = .tbyte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .f80, .kind = .{ .reg = .st7 } },
                            .{ .type = .u16, .kind = .mem },
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f80, .kind = .{ .reg = .st6 } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .x87 }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, .f_, .ld, .mem(.src0t), ._, ._, ._ },
                            .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
                            .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
                            .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_00_11), ._, ._ },
                            .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                            .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
                            .{ ._, ._, .mov, .tmp2p, .sia(16, .src0, .sub_unaligned_size), ._, ._ },
                            .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp2, .add_unaligned_size), ._, ._, ._ },
                            .{ ._, .f_p, .mul, ._, ._, ._, ._ },
                            .{ ._, ._, .add, .tmp2p, .si(16), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                            .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0x, .mem(.src0x), ._, ._ },
                            .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .mem(.src0x), ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_unaligned_size), ._, ._ },
                            .{ ._, ._ps, .mova, .dst0x, .mem(.src0x), ._, ._ },
                            .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } },
                            .{ .type = .f128, .kind = .mem },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_unaligned_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp2p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.tmp4), ._, ._ },
                            .{ ._, .v_dqa, .mov, .lea(.tmp1x), .dst0x, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } },
                            .{ .type = .f128, .kind = .mem },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_unaligned_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp2p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.tmp4), ._, ._ },
                            .{ ._, ._dqa, .mov, .lea(.tmp1x), .dst0x, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } },
                            .{ .type = .f128, .kind = .mem },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_unaligned_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp2p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.tmp4), ._, ._ },
                            .{ ._, ._ps, .mova, .lea(.tmp1x), .dst0x, ._, ._ },
                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                        } },
                    } },
                }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s}.{s} {f} {f}", .{
                        @tagName(air_tag),
                        @tagName(reduce.operation),
                        cg.typeOf(reduce.operand).fmt(pt),
                        ops[0].tracking(cg),
                    }),
                    else => |e| return e,
                };
                switch (reduce.operation) {
                    .And, .Or, .Xor, .Min, .Max => {},
                    .Add, .Mul => if (cg.intInfo(res_ty)) |_| res[0].wrapInt(cg) catch |err| switch (err) {
                        error.SelectFailed => return cg.fail("failed to select {s}.{s} wrap {f} {f}", .{
                            @tagName(air_tag),
                            @tagName(reduce.operation),
                            res_ty.fmt(pt),
                            res[0].tracking(cg),
                        }),
                        else => |e| return e,
                    },
                }
                try res[0].finish(inst, &.{reduce.operand}, &ops, cg);
            },
            .reduce_optimized => |air_tag| {
                const inf = std.math.inf(f16);
                const reduce = air_datas[@intFromEnum(inst)].reduce;
                var ops = try cg.tempsFromOperands(inst, .{reduce.operand});
                var res: [1]Temp = undefined;
                cg.select(&res, &.{cg.typeOfIndex(inst)}, &ops, switch (reduce.operation) {
                    .And, .Or, .Xor => unreachable,
                    .Min => comptime &.{ .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .dword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ss, .min, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .min, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_f16, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = inf } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"or", .dst0x, .src0x, .lea(.tmp0x), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .min, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .min, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .min, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .min, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_f16, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = inf } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp3y, .tmp3x, ._, ._ },
                            .{ ._, .v_ps, .min, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .min, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .min, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp0y, .tmp0x, ._, ._ },
                            .{ ._, .v_ps, .min, .dst0y, .dst0y, .tmp0y, ._ },
                            .{ ._, .v_f128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .min, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .min, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .zword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_32_f16, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = inf } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_ps, .mova, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"and", .tmp3y, .tmp3y, .memd(.src0y, 32), ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .mem(.src0y), ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_ps, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, .v_f128, .extract, .tmp4x, .tmp3y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp3y, .tmp3x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp4y, .tmp4x, ._, ._ },
                            .{ ._, .v_ps, .min, .tmp3y, .tmp3y, .tmp4y, ._ },
                            .{ ._, .v_f128, .extract, .tmp4x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp4y, .tmp4x, ._, ._ },
                            .{ ._, .v_ps, .min, .dst0y, .dst0y, .tmp4y, ._ },
                            .{ ._, .v_ps, .min, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .min, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .min, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .zword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .mova, .tmp0y, .memd(.src0y, 32), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp1x, .tmp0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp0y, .tmp0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp1y, .tmp1x, ._, ._ },
                            .{ ._, .v_ps, .min, .tmp0y, .tmp0y, .tmp1y, ._ },
                            .{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp1y, .tmp1x, ._, ._ },
                            .{ ._, .v_ps, .min, .dst0y, .dst0y, .tmp1y, ._ },
                            .{ ._, .v_ps, .min, .dst0y, .dst0y, .tmp0y, ._ },
                            .{ ._, .v_f128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .min, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .min, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_float = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .v_ps, .min, .dst0y, .dst0y, .tmp1y, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .min, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .min, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .zword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_32_f16, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = inf } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_ps, .mova, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"and", .tmp3y, .tmp3y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_ps, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-80, .src0, .add_size), ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp4x, .tmp3y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp3y, .tmp3x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp4y, .tmp4x, ._, ._ },
                            .{ ._, .v_ps, .min, .tmp3y, .tmp3y, .tmp4y, ._ },
                            .{ ._, .v_f128, .extract, .tmp4x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp4y, .tmp4x, ._, ._ },
                            .{ ._, .v_ps, .min, .dst0y, .dst0y, .tmp4y, ._ },
                            .{ ._, .v_ps, .min, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ .@"0:", .v_ps, .cvtph2, .tmp3y, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .v_ps, .min, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .min, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .min, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_f16, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = inf } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp3y, .tmp3x, ._, ._ },
                            .{ ._, .v_ps, .min, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ .@"0:", .v_ps, .cvtph2, .tmp3y, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .v_ps, .min, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .min, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .min, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__fminh" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .vp_w, .insr, .dst0x, .dst0x, .memad(.src0w, .add_unaligned_size, -2), .ui(0) },
                            .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
                            .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__fminh" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, .p_, .xor, .dst0x, .dst0x, ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .p_w, .insr, .dst0x, .memad(.src0w, .add_unaligned_size, -2), .ui(0), ._ },
                            .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f16, .kind = .{ .reg = .ax } },
                            .{ .type = .f32, .kind = .mem },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__fminh" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .movzx, .tmp1d, .memad(.src0w, .add_unaligned_size, -2), ._, ._ },
                            .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                            .{ ._, ._ss, .mov, .dst0x, .mem(.tmp2d), ._, ._ },
                            .{ .@"0:", ._ps, .xor, .tmp3x, .tmp3x, ._, ._ },
                            .{ ._, ._ss, .mov, .tmp3x, .memi(.src0d, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .shuf, .tmp0x, .src0x, .src0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .dst0x, .src0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .mova, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .tmp0x, .tmp0x, .ui(0b01), ._ },
                            .{ ._, ._ss, .min, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .movhl, .tmp0x, .src0x, .src0x, ._ },
                            .{ ._, .v_ss, .min, .tmp0x, .src0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .dst0x, .src0x, .src0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .dst0x, .tmp0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .xor, .tmp0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._ss, .min, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .dst0x, .src0x, .ui(0b01), ._ },
                            .{ ._, ._ss, .min, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .movhl, .tmp0x, .src0x, .src0x, ._ },
                            .{ ._, .v_ps, .min, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .xor, .tmp0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._ps, .min, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .mova, .tmp0x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .tmp0x, .tmp0x, .ui(0b01), ._ },
                            .{ ._, ._ss, .min, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_f32, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = inf } } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .min, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp3x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .min, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .v_ps, .min, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp0x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .min, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .zword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_f32, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = inf } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_ps, .mova, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .mem(.src0y), ._ },
                            .{ ._, .v_ps, .@"and", .tmp3y, .tmp3y, .memd(.src0y, 32), ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_ps, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, .v_ps, .min, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .min, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp3x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .min, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .zword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .mova, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .v_ps, .mova, .tmp0y, .memd(.src0y, 32), ._, ._ },
                            .{ ._, .v_ps, .min, .dst0y, .dst0y, .tmp0y, ._ },
                            .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .min, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp0x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .min, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                            .{ .@"0:", .v_ps, .min, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .min, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp1x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .min, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._ps, .mova, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._ps, .min, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .min, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .mova, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .tmp1x, .tmp1x, .ui(0b01), ._ },
                            .{ ._, ._ss, .min, .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .zword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_f32, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = inf } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_ps, .mova, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"and", .tmp3y, .tmp3y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_ps, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ },
                            .{ .@"0:", .v_ps, .min, .tmp3y, .tmp3y, .memid(.src0y, .tmp0, 32), ._ },
                            .{ ._, .v_ps, .min, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_ps, .min, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .min, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp3x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .min, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_f32, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = inf } } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .min, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ .@"0:", .v_ps, .min, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_ps, .movhl, .tmp3x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .min, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .min, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_f32, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = inf } } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._ps, .mova, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, ._ps, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, ._ps, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ .@"0:", ._ps, .min, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._ps, .xor, .tmp3x, .tmp3x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp3x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .min, .dst0x, .tmp3x, ._, ._ },
                            .{ ._, ._ps, .mova, .tmp3x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .tmp3x, .tmp3x, .ui(0b01), ._ },
                            .{ ._, ._ss, .min, .dst0x, .tmp3x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .movhl, .tmp0x, .src0x, .src0x, ._ },
                            .{ ._, .v_sd, .min, .dst0x, .src0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .xor, .tmp0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._sd, .min, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .v_sd, .min, .tmp0x, .src0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .movhl, .dst0x, .src0x, .src0x, ._ },
                            .{ ._, .v_sd, .min, .dst0x, .tmp0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .v_pd, .min, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp0x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_sd, .min, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .zword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_f64, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = inf } } },
                            .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_pd, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_pd, .mova, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_pd, .@"and", .dst0y, .dst0y, .mem(.src0y), ._ },
                            .{ ._, .v_pd, .@"and", .tmp3y, .tmp3y, .memd(.src0y, 32), ._ },
                            .{ ._, .v_pd, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_pd, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, .v_pd, .min, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_pd, .min, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp3x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_sd, .min, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .zword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_pd, .mova, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .v_pd, .mova, .tmp0y, .memd(.src0y, 32), ._, ._ },
                            .{ ._, .v_pd, .min, .dst0y, .dst0y, .tmp0y, ._ },
                            .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_pd, .min, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp0x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_sd, .min, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_pd, .mova, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                            .{ .@"0:", .v_pd, .min, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_pd, .min, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp1x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_sd, .min, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._pd, .mova, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._pd, .min, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, ._sd, .min, .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .zword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_f64, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = inf } } },
                            .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_pd, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_pd, .mova, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_pd, .@"and", .tmp3y, .tmp3y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_pd, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                            .{ ._, .v_pd, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_pd, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ },
                            .{ .@"0:", .v_pd, .min, .tmp3y, .tmp3y, .memid(.src0y, .tmp0, 32), ._ },
                            .{ ._, .v_pd, .min, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_pd, .min, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_pd, .min, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp3x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_sd, .min, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_f64, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = inf } } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_pd, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_pd, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_pd, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_pd, .min, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ .@"0:", .v_pd, .min, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_ps, .movhl, .tmp3x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_sd, .min, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_2_f64, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = inf } } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._pd, .mova, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, ._pd, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, ._pd, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ .@"0:", ._pd, .min, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._ps, .xor, .tmp3x, .tmp3x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp3x, .dst0x, ._, ._ },
                            .{ ._, ._sd, .min, .dst0x, .tmp3x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .x87, .cmov, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f64, .kind = .{ .reg = .st7 } },
                            .{ .type = .f64, .kind = .{ .reg = .st6 } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .f_, .ld, .memad(.src0q, .add_unaligned_size, -8), ._, ._, ._ },
                            .{ .@"0:", .f_, .ld, .memi(.src0q, .tmp0), ._, ._, ._ },
                            .{ ._, .f_, .ucomi, .tmp2t, .tmp1t, ._, ._ },
                            .{ ._, .f_nb, .cmov, .tmp2t, .tmp1t, ._, ._ },
                            .{ ._, .f_p, .st, .tmp1t, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sahf, .x87, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f64, .kind = .{ .reg = .st7 } },
                            .{ .type = .f64, .kind = .{ .reg = .st6 } },
                            .{ .type = .u16, .kind = .{ .reg = .ax } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .f_, .ld, .memad(.src0q, .add_unaligned_size, -8), ._, ._, ._ },
                            .{ .@"0:", .f_, .ld, .memi(.src0q, .tmp0), ._, ._, ._ },
                            .{ ._, .f_, .ucom, .tmp1t, ._, ._, ._ },
                            .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ },
                            .{ ._, ._, .sahf, ._, ._, ._, ._ },
                            .{ ._, ._nb, .j, .@"1f", ._, ._, ._ },
                            .{ ._, .f_, .st, .tmp1t, ._, ._, ._ },
                            .{ .@"1:", .f_p, .st, .tmp2t, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .x87, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f64, .kind = .{ .reg = .st7 } },
                            .{ .type = .f64, .kind = .{ .reg = .st6 } },
                            .{ .type = .u16, .kind = .{ .reg = .ax } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .f_, .ld, .memad(.src0q, .add_unaligned_size, -8), ._, ._, ._ },
                            .{ .@"0:", .f_, .ld, .memi(.src0q, .tmp0), ._, ._, ._ },
                            .{ ._, .f_, .ucom, .tmp1t, ._, ._, ._ },
                            .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ },
                            .{ ._, ._, .@"test", .tmp3h, .si(0b0_000_001), ._, ._ },
                            .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                            .{ ._, .f_, .st, .tmp1t, ._, ._, ._ },
                            .{ .@"1:", .f_p, .st, .tmp2t, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .x87, .cmov, null, null },
                        .dst_constraints = .{ .{ .float = .tbyte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f80, .kind = .{ .reg = .st7 } },
                            .{ .type = .f80, .kind = .{ .reg = .st6 } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .x87 }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .f_, .ld, .memad(.src0t, .add_unaligned_size, -16), ._, ._, ._ },
                            .{ .@"0:", .f_, .ld, .memi(.src0t, .tmp0), ._, ._, ._ },
                            .{ ._, .f_, .ucomi, .tmp2t, .tmp1t, ._, ._ },
                            .{ ._, .f_nb, .cmov, .tmp2t, .tmp1t, ._, ._ },
                            .{ ._, .f_p, .st, .tmp1t, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sahf, .x87, null, null },
                        .dst_constraints = .{ .{ .float = .tbyte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f80, .kind = .{ .reg = .st7 } },
                            .{ .type = .f80, .kind = .{ .reg = .st6 } },
                            .{ .type = .u16, .kind = .{ .reg = .ax } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .x87 }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .f_, .ld, .memad(.src0t, .add_unaligned_size, -16), ._, ._, ._ },
                            .{ .@"0:", .f_, .ld, .memi(.src0t, .tmp0), ._, ._, ._ },
                            .{ ._, .f_, .ucom, .tmp1t, ._, ._, ._ },
                            .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ },
                            .{ ._, ._, .sahf, ._, ._, ._, ._ },
                            .{ ._, ._nb, .j, .@"1f", ._, ._, ._ },
                            .{ ._, .f_, .st, .tmp1t, ._, ._, ._ },
                            .{ .@"1:", .f_p, .st, .tmp2t, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .x87, null, null, null },
                        .dst_constraints = .{ .{ .float = .tbyte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f80, .kind = .{ .reg = .st7 } },
                            .{ .type = .f80, .kind = .{ .reg = .st6 } },
                            .{ .type = .u16, .kind = .{ .reg = .ax } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .x87 }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .f_, .ld, .memad(.src0t, .add_unaligned_size, -16), ._, ._, ._ },
                            .{ .@"0:", .f_, .ld, .memi(.src0t, .tmp0), ._, ._, ._ },
                            .{ ._, .f_, .ucom, .tmp1t, ._, ._, ._ },
                            .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ },
                            .{ ._, ._, .@"test", .tmp3h, .si(0b0_000_001), ._, ._ },
                            .{ ._, ._z, .j, .@"1f", ._, ._, ._ },
                            .{ ._, .f_, .st, .tmp1t, ._, ._, ._ },
                            .{ .@"1:", .f_p, .st, .tmp2t, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "fminq" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "fminq" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "fminq" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._ps, .mova, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "fminq" } },
                            .{ .type = .f128, .kind = .mem },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp2p, .memi(.src0, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.tmp4), ._, ._ },
                            .{ ._, .v_dqa, .mov, .lea(.tmp1x), .dst0x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "fminq" } },
                            .{ .type = .f128, .kind = .mem },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp2p, .memi(.src0, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.tmp4), ._, ._ },
                            .{ ._, ._dqa, .mov, .lea(.tmp1x), .dst0x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "fminq" } },
                            .{ .type = .f128, .kind = .mem },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp2p, .memi(.src0, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.tmp4), ._, ._ },
                            .{ ._, ._ps, .mova, .lea(.tmp1x), .dst0x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    } },
                    .Max => comptime &.{ .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .dword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ss, .max, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .max, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_f16, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = -inf } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"or", .dst0x, .src0x, .lea(.tmp0x), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .max, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .max, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .max, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .max, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_f16, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = -inf } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp3y, .tmp3x, ._, ._ },
                            .{ ._, .v_ps, .max, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .max, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .max, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp0y, .tmp0x, ._, ._ },
                            .{ ._, .v_ps, .max, .dst0y, .dst0y, .tmp0y, ._ },
                            .{ ._, .v_f128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .max, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .max, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .zword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_32_f16, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = -inf } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_ps, .mova, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"and", .tmp3y, .tmp3y, .memd(.src0y, 32), ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .mem(.src0y), ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_ps, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, .v_f128, .extract, .tmp4x, .tmp3y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp3y, .tmp3x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp4y, .tmp4x, ._, ._ },
                            .{ ._, .v_ps, .max, .tmp3y, .tmp3y, .tmp4y, ._ },
                            .{ ._, .v_f128, .extract, .tmp4x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp4y, .tmp4x, ._, ._ },
                            .{ ._, .v_ps, .max, .dst0y, .dst0y, .tmp4y, ._ },
                            .{ ._, .v_ps, .max, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .max, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .max, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .zword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .mova, .tmp0y, .memd(.src0y, 32), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp1x, .tmp0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp0y, .tmp0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp1y, .tmp1x, ._, ._ },
                            .{ ._, .v_ps, .max, .tmp0y, .tmp0y, .tmp1y, ._ },
                            .{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp1y, .tmp1x, ._, ._ },
                            .{ ._, .v_ps, .max, .dst0y, .dst0y, .tmp1y, ._ },
                            .{ ._, .v_ps, .max, .dst0y, .dst0y, .tmp0y, ._ },
                            .{ ._, .v_f128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .max, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .max, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_float = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .v_ps, .max, .dst0y, .dst0y, .tmp1y, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .max, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .max, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .zword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_32_f16, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = -inf } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_ps, .mova, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"and", .tmp3y, .tmp3y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_ps, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-80, .src0, .add_size), ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp4x, .tmp3y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp3y, .tmp3x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp4y, .tmp4x, ._, ._ },
                            .{ ._, .v_ps, .max, .tmp3y, .tmp3y, .tmp4y, ._ },
                            .{ ._, .v_f128, .extract, .tmp4x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp4y, .tmp4x, ._, ._ },
                            .{ ._, .v_ps, .max, .dst0y, .dst0y, .tmp4y, ._ },
                            .{ ._, .v_ps, .max, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ .@"0:", .v_ps, .cvtph2, .tmp3y, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .v_ps, .max, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .max, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .max, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_f16, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = -inf } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp3y, .tmp3x, ._, ._ },
                            .{ ._, .v_ps, .max, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ .@"0:", .v_ps, .cvtph2, .tmp3y, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .v_ps, .max, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .max, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .max, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__fmaxh" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .vp_w, .insr, .dst0x, .dst0x, .memad(.src0w, .add_unaligned_size, -2), .ui(0) },
                            .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
                            .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__fmaxh" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, .p_, .xor, .dst0x, .dst0x, ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .p_w, .insr, .dst0x, .memad(.src0w, .add_unaligned_size, -2), .ui(0), ._ },
                            .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f16, .kind = .{ .reg = .ax } },
                            .{ .type = .f32, .kind = .mem },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__fmaxh" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .movzx, .tmp1d, .memad(.src0w, .add_unaligned_size, -2), ._, ._ },
                            .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                            .{ ._, ._ss, .mov, .dst0x, .mem(.tmp2d), ._, ._ },
                            .{ .@"0:", ._ps, .xor, .tmp3x, .tmp3x, ._, ._ },
                            .{ ._, ._ss, .mov, .tmp3x, .memi(.src0d, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .shuf, .tmp0x, .src0x, .src0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .dst0x, .src0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .mova, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .tmp0x, .tmp0x, .ui(0b01), ._ },
                            .{ ._, ._ss, .max, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .movhl, .tmp0x, .src0x, .src0x, ._ },
                            .{ ._, .v_ss, .max, .tmp0x, .src0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .dst0x, .src0x, .src0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .dst0x, .tmp0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .xor, .tmp0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._ss, .max, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .dst0x, .src0x, .ui(0b01), ._ },
                            .{ ._, ._ss, .max, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .movhl, .tmp0x, .src0x, .src0x, ._ },
                            .{ ._, .v_ps, .max, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .xor, .tmp0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._ps, .max, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .mova, .tmp0x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .tmp0x, .tmp0x, .ui(0b01), ._ },
                            .{ ._, ._ss, .max, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_f32, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = -inf } } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .max, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp3x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .max, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .v_ps, .max, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp0x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .max, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .zword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_f32, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = -inf } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_ps, .mova, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .mem(.src0y), ._ },
                            .{ ._, .v_ps, .@"and", .tmp3y, .tmp3y, .memd(.src0y, 32), ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_ps, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, .v_ps, .max, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .max, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp3x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .max, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .zword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .mova, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .v_ps, .mova, .tmp0y, .memd(.src0y, 32), ._, ._ },
                            .{ ._, .v_ps, .max, .dst0y, .dst0y, .tmp0y, ._ },
                            .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .max, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp0x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .max, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                            .{ .@"0:", .v_ps, .max, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .max, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp1x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .max, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._ps, .mova, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._ps, .max, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .max, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .mova, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .tmp1x, .tmp1x, .ui(0b01), ._ },
                            .{ ._, ._ss, .max, .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .zword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_f32, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = -inf } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_ps, .mova, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"and", .tmp3y, .tmp3y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_ps, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ },
                            .{ .@"0:", .v_ps, .max, .tmp3y, .tmp3y, .memid(.src0y, .tmp0, 32), ._ },
                            .{ ._, .v_ps, .max, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_ps, .max, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .max, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp3x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .max, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_f32, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = -inf } } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .max, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ .@"0:", .v_ps, .max, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_ps, .movhl, .tmp3x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .max, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .max, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_f32, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = -inf } } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._ps, .mova, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, ._ps, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, ._ps, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ .@"0:", ._ps, .max, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._ps, .xor, .tmp3x, .tmp3x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp3x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .max, .dst0x, .tmp3x, ._, ._ },
                            .{ ._, ._ps, .mova, .tmp3x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .tmp3x, .tmp3x, .ui(0b01), ._ },
                            .{ ._, ._ss, .max, .dst0x, .tmp3x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .movhl, .tmp0x, .src0x, .src0x, ._ },
                            .{ ._, .v_sd, .max, .dst0x, .src0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .xor, .tmp0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._sd, .max, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .v_sd, .max, .tmp0x, .src0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .movhl, .dst0x, .src0x, .src0x, ._ },
                            .{ ._, .v_sd, .max, .dst0x, .tmp0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .v_pd, .max, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp0x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_sd, .max, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .zword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_f64, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = -inf } } },
                            .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_pd, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_pd, .mova, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_pd, .@"and", .dst0y, .dst0y, .mem(.src0y), ._ },
                            .{ ._, .v_pd, .@"and", .tmp3y, .tmp3y, .memd(.src0y, 32), ._ },
                            .{ ._, .v_pd, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_pd, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, .v_pd, .max, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_pd, .max, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp3x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_sd, .max, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .zword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_pd, .mova, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .v_pd, .mova, .tmp0y, .memd(.src0y, 32), ._, ._ },
                            .{ ._, .v_pd, .max, .dst0y, .dst0y, .tmp0y, ._ },
                            .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_pd, .max, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp0x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_sd, .max, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_pd, .mova, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                            .{ .@"0:", .v_pd, .max, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_pd, .max, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp1x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_sd, .max, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._pd, .mova, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._pd, .max, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, ._sd, .max, .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .zword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_f64, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = -inf } } },
                            .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_pd, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_pd, .mova, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_pd, .@"and", .tmp3y, .tmp3y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_pd, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                            .{ ._, .v_pd, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_pd, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ },
                            .{ .@"0:", .v_pd, .max, .tmp3y, .tmp3y, .memid(.src0y, .tmp0, 32), ._ },
                            .{ ._, .v_pd, .max, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_pd, .max, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_pd, .max, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp3x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_sd, .max, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_f64, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = -inf } } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_pd, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_pd, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_pd, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_pd, .max, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ .@"0:", .v_pd, .max, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_ps, .movhl, .tmp3x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_sd, .max, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_2_f64, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = -inf } } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._pd, .mova, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, ._pd, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, ._pd, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ .@"0:", ._pd, .max, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._ps, .xor, .tmp3x, .tmp3x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp3x, .dst0x, ._, ._ },
                            .{ ._, ._sd, .max, .dst0x, .tmp3x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .x87, .cmov, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f64, .kind = .{ .reg = .st7 } },
                            .{ .type = .f64, .kind = .{ .reg = .st6 } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .f_, .ld, .memad(.src0q, .add_unaligned_size, -8), ._, ._, ._ },
                            .{ .@"0:", .f_, .ld, .memi(.src0q, .tmp0), ._, ._, ._ },
                            .{ ._, .f_, .ucomi, .tmp2t, .tmp1t, ._, ._ },
                            .{ ._, .f_b, .cmov, .tmp2t, .tmp1t, ._, ._ },
                            .{ ._, .f_p, .st, .tmp1t, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sahf, .x87, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f64, .kind = .{ .reg = .st7 } },
                            .{ .type = .f64, .kind = .{ .reg = .st6 } },
                            .{ .type = .u16, .kind = .{ .reg = .ax } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .f_, .ld, .memad(.src0q, .add_unaligned_size, -8), ._, ._, ._ },
                            .{ .@"0:", .f_, .ld, .memi(.src0q, .tmp0), ._, ._, ._ },
                            .{ ._, .f_, .ucom, .tmp1t, ._, ._, ._ },
                            .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ },
                            .{ ._, ._, .sahf, ._, ._, ._, ._ },
                            .{ ._, ._b, .j, .@"1f", ._, ._, ._ },
                            .{ ._, .f_, .st, .tmp1t, ._, ._, ._ },
                            .{ .@"1:", .f_p, .st, .tmp2t, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .x87, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f64, .kind = .{ .reg = .st7 } },
                            .{ .type = .f64, .kind = .{ .reg = .st6 } },
                            .{ .type = .u16, .kind = .{ .reg = .ax } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .f_, .ld, .memad(.src0q, .add_unaligned_size, -8), ._, ._, ._ },
                            .{ .@"0:", .f_, .ld, .memi(.src0q, .tmp0), ._, ._, ._ },
                            .{ ._, .f_, .ucom, .tmp1t, ._, ._, ._ },
                            .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ },
                            .{ ._, ._, .@"test", .tmp3h, .si(0b0_000_001), ._, ._ },
                            .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                            .{ ._, .f_, .st, .tmp1t, ._, ._, ._ },
                            .{ .@"1:", .f_p, .st, .tmp2t, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .x87, .cmov, null, null },
                        .dst_constraints = .{ .{ .float = .tbyte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f80, .kind = .{ .reg = .st7 } },
                            .{ .type = .f80, .kind = .{ .reg = .st6 } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .x87 }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .f_, .ld, .memad(.src0t, .add_unaligned_size, -16), ._, ._, ._ },
                            .{ .@"0:", .f_, .ld, .memi(.src0t, .tmp0), ._, ._, ._ },
                            .{ ._, .f_, .ucomi, .tmp2t, .tmp1t, ._, ._ },
                            .{ ._, .f_b, .cmov, .tmp2t, .tmp1t, ._, ._ },
                            .{ ._, .f_p, .st, .tmp1t, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sahf, .x87, null, null },
                        .dst_constraints = .{ .{ .float = .tbyte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f80, .kind = .{ .reg = .st7 } },
                            .{ .type = .f80, .kind = .{ .reg = .st6 } },
                            .{ .type = .u16, .kind = .{ .reg = .ax } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .x87 }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .f_, .ld, .memad(.src0t, .add_unaligned_size, -16), ._, ._, ._ },
                            .{ .@"0:", .f_, .ld, .memi(.src0t, .tmp0), ._, ._, ._ },
                            .{ ._, .f_, .ucom, .tmp1t, ._, ._, ._ },
                            .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ },
                            .{ ._, ._, .sahf, ._, ._, ._, ._ },
                            .{ ._, ._b, .j, .@"1f", ._, ._, ._ },
                            .{ ._, .f_, .st, .tmp1t, ._, ._, ._ },
                            .{ .@"1:", .f_p, .st, .tmp2t, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .x87, null, null, null },
                        .dst_constraints = .{ .{ .float = .tbyte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f80, .kind = .{ .reg = .st7 } },
                            .{ .type = .f80, .kind = .{ .reg = .st6 } },
                            .{ .type = .u16, .kind = .{ .reg = .ax } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .x87 }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .f_, .ld, .memad(.src0t, .add_unaligned_size, -16), ._, ._, ._ },
                            .{ .@"0:", .f_, .ld, .memi(.src0t, .tmp0), ._, ._, ._ },
                            .{ ._, .f_, .ucom, .tmp1t, ._, ._, ._ },
                            .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ },
                            .{ ._, ._, .@"test", .tmp3h, .si(0b0_000_001), ._, ._ },
                            .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                            .{ ._, .f_, .st, .tmp1t, ._, ._, ._ },
                            .{ .@"1:", .f_p, .st, .tmp2t, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "fmaxq" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "fmaxq" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "fmaxq" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._ps, .mova, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "fmaxq" } },
                            .{ .type = .f128, .kind = .mem },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp2p, .memi(.src0, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.tmp4), ._, ._ },
                            .{ ._, .v_dqa, .mov, .lea(.tmp1x), .dst0x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "fmaxq" } },
                            .{ .type = .f128, .kind = .mem },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp2p, .memi(.src0, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.tmp4), ._, ._ },
                            .{ ._, ._dqa, .mov, .lea(.tmp1x), .dst0x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "fmaxq" } },
                            .{ .type = .f128, .kind = .mem },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp2p, .memi(.src0, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.tmp4), ._, ._ },
                            .{ ._, ._ps, .mova, .lea(.tmp1x), .dst0x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    } },
                    .Add => comptime &.{ .{
                        .required_features = .{ .f16c, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .dword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                            .{ ._, .vh_ps, .add, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .dword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                            .{ ._, .vh_ps, .add, .tmp0x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .shuf, .dst0x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ss, .add, .dst0x, .tmp0x, .dst0x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ss, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                            .{ ._, .vh_ps, .add, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, .vh_ps, .add, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                            .{ ._, .vh_ps, .add, .dst0y, .dst0y, .dst0y, ._ },
                            .{ ._, .vh_ps, .add, .dst0y, .dst0y, .dst0y, ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ss, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
                            .{ ._, .vh_ps, .add, .dst0y, .dst0y, .dst0y, ._ },
                            .{ ._, .vh_ps, .add, .dst0y, .dst0y, .dst0y, ._ },
                            .{ ._, .v_f128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ss, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp2y, .tmp2x, ._, ._ },
                            .{ ._, .v_ps, .add, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .vh_ps, .add, .dst0y, .dst0y, .dst0y, ._ },
                            .{ ._, .vh_ps, .add, .dst0y, .dst0y, .dst0y, ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ss, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp2y, .tmp2x, ._, ._ },
                            .{ ._, .v_ps, .add, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp0y, .tmp0x, ._, ._ },
                            .{ ._, .v_ps, .add, .dst0y, .dst0y, .tmp0y, ._ },
                            .{ ._, .vh_ps, .add, .dst0y, .dst0y, .dst0y, ._ },
                            .{ ._, .vh_ps, .add, .dst0y, .dst0y, .dst0y, ._ },
                            .{ ._, .v_f128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ss, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp0y, .tmp0x, ._, ._ },
                            .{ ._, .v_ps, .add, .dst0y, .dst0y, .tmp0y, ._ },
                            .{ ._, .v_f128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .zword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_ps, .mova, .tmp2y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, .v_ps, .@"and", .tmp2y, .tmp2y, .memd(.src0y, 32), ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .mem(.src0y), ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .tmp2y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp2y, .tmp2x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp3y, .tmp3x, ._, ._ },
                            .{ ._, .v_ps, .add, .tmp2y, .tmp2y, .tmp3y, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp3y, .tmp3x, ._, ._ },
                            .{ ._, .v_ps, .add, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_ps, .add, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .zword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .mova, .tmp0y, .memd(.src0y, 32), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp1x, .tmp0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp0y, .tmp0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp1y, .tmp1x, ._, ._ },
                            .{ ._, .v_ps, .add, .tmp0y, .tmp0y, .tmp1y, ._ },
                            .{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp1y, .tmp1x, ._, ._ },
                            .{ ._, .v_ps, .add, .dst0y, .dst0y, .tmp1y, ._ },
                            .{ ._, .v_ps, .add, .dst0y, .dst0y, .tmp0y, ._ },
                            .{ ._, .v_f128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_float = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .v_ps, .add, .dst0y, .dst0y, .tmp1y, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vh_ps, .add, .dst0y, .dst0y, .dst0y, ._ },
                            .{ ._, .vh_ps, .add, .dst0y, .dst0y, .dst0y, ._ },
                            .{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ss, .add, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_float = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .v_ps, .add, .dst0y, .dst0y, .tmp1y, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .add, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .add, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .add, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .zword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_ps, .mova, .tmp2y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-80, .src0, .add_size), ._, ._ },
                            .{ ._, .v_ps, .@"and", .tmp2y, .tmp2y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .tmp2y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp2y, .tmp2x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp3y, .tmp3x, ._, ._ },
                            .{ ._, .v_ps, .add, .tmp2y, .tmp2y, .tmp3y, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp3y, .tmp3x, ._, ._ },
                            .{ ._, .v_ps, .add, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_ps, .add, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ .@"0:", .v_ps, .cvtph2, .tmp2y, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .v_ps, .add, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp2y, .tmp2x, ._, ._ },
                            .{ ._, .v_ps, .add, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ .@"0:", .v_ps, .cvtph2, .tmp2y, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .v_ps, .add, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vh_ps, .add, .dst0y, .dst0y, .dst0y, ._ },
                            .{ ._, .vh_ps, .add, .dst0y, .dst0y, .dst0y, ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ss, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp2y, .tmp2x, ._, ._ },
                            .{ ._, .v_ps, .add, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ .@"0:", .v_ps, .cvtph2, .tmp2y, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .v_ps, .add, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .vp_w, .insr, .dst0x, .dst0x, .memad(.src0w, .add_unaligned_size, -2), .ui(0) },
                            .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
                            .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, .p_, .xor, .dst0x, .dst0x, ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .p_w, .insr, .dst0x, .memad(.src0w, .add_unaligned_size, -2), .ui(0), ._ },
                            .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f16, .kind = .{ .reg = .ax } },
                            .{ .type = .f32, .kind = .mem },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .movzx, .tmp1d, .memad(.src0w, .add_unaligned_size, -2), ._, ._ },
                            .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                            .{ ._, ._ss, .mov, .dst0x, .mem(.tmp2d), ._, ._ },
                            .{ .@"0:", ._ps, .xor, .tmp3x, .tmp3x, ._, ._ },
                            .{ ._, ._ss, .mov, .tmp3x, .memi(.src0d, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vh_ps, .add, .dst0x, .src0x, .src0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .shuf, .tmp0x, .src0x, .src0x, .ui(0b01) },
                            .{ ._, .v_ss, .add, .dst0x, .src0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse3, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .h_ps, .add, .dst0x, .src0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .mova, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .tmp0x, .tmp0x, .ui(0b01), ._ },
                            .{ ._, ._ss, .add, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vh_ps, .add, .tmp0x, .src0x, .src0x, ._ },
                            .{ ._, .v_ps, .movhl, .dst0x, .src0x, .src0x, ._ },
                            .{ ._, .v_ss, .add, .dst0x, .tmp0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .movhl, .tmp0x, .src0x, .src0x, ._ },
                            .{ ._, .v_ss, .add, .tmp0x, .src0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .dst0x, .src0x, .src0x, .ui(0b01) },
                            .{ ._, .v_ss, .add, .dst0x, .tmp0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse3, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .xor, .tmp0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp0x, .src0x, ._, ._ },
                            .{ ._, .h_ps, .add, .dst0x, .src0x, ._, ._ },
                            .{ ._, ._ss, .add, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .xor, .tmp0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._ss, .add, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .dst0x, .src0x, .ui(0b01), ._ },
                            .{ ._, ._ss, .add, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vh_ps, .add, .dst0x, .src0x, .src0x, ._ },
                            .{ ._, .vh_ps, .add, .dst0x, .dst0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .movhl, .tmp0x, .src0x, .src0x, ._ },
                            .{ ._, .v_ps, .add, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .add, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse3, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .h_ps, .add, .dst0x, .src0x, ._, ._ },
                            .{ ._, .h_ps, .add, .dst0x, .dst0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .xor, .tmp0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._ps, .add, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .mova, .tmp0x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .tmp0x, .tmp0x, .ui(0b01), ._ },
                            .{ ._, ._ss, .add, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, .vh_ps, .add, .dst0y, .dst0y, .dst0y, ._ },
                            .{ ._, .vh_ps, .add, .dst0y, .dst0y, .dst0y, ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ss, .add, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp2x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .add, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vh_ps, .add, .dst0y, .dst0y, .dst0y, ._ },
                            .{ ._, .vh_ps, .add, .dst0y, .dst0y, .dst0y, ._ },
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .v_ss, .add, .dst0x, .src0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .v_ps, .add, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp0x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .add, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .zword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_ps, .mova, .tmp2y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .mem(.src0y), ._ },
                            .{ ._, .v_ps, .@"and", .tmp2y, .tmp2y, .memd(.src0y, 32), ._ },
                            .{ ._, .v_ps, .add, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp2x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .add, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .zword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .mova, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .v_ps, .mova, .tmp0y, .memd(.src0y, 32), ._, ._ },
                            .{ ._, .v_ps, .add, .dst0y, .dst0y, .tmp0y, ._ },
                            .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp0x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .add, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                            .{ .@"0:", .v_ps, .add, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vh_ps, .add, .dst0y, .dst0y, .dst0y, ._ },
                            .{ ._, .vh_ps, .add, .dst0y, .dst0y, .dst0y, ._ },
                            .{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ss, .add, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                            .{ .@"0:", .v_ps, .add, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .add, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp1x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .add, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .add, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse3, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._ps, .mova, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._ps, .add, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .h_ps, .add, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .h_ps, .add, .dst0x, .dst0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._ps, .mova, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._ps, .add, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .add, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .mova, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .tmp1x, .tmp1x, .ui(0b01), ._ },
                            .{ ._, ._ss, .add, .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .zword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_ps, .mova, .tmp2y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ },
                            .{ ._, .v_ps, .@"and", .tmp2y, .tmp2y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                            .{ .@"0:", .v_ps, .add, .tmp2y, .tmp2y, .memid(.src0y, .tmp0, 32), ._ },
                            .{ ._, .v_ps, .add, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_ps, .add, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp2x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .add, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ .@"0:", .v_ps, .add, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vh_ps, .add, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, .vh_ps, .add, .dst0x, .dst0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ .@"0:", .v_ps, .add, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_ps, .movhl, .tmp2x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .add, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse3, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._ps, .mova, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ ._, ._ps, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ .@"0:", ._ps, .add, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .h_ps, .add, .dst0x, .dst0x, ._, ._ },
                            .{ ._, .h_ps, .add, .dst0x, .dst0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._ps, .mova, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ ._, ._ps, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ .@"0:", ._ps, .add, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._ps, .xor, .tmp2x, .tmp2x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .add, .dst0x, .tmp2x, ._, ._ },
                            .{ ._, ._ps, .mova, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .tmp2x, .tmp2x, .ui(0b01), ._ },
                            .{ ._, ._ss, .add, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vh_pd, .add, .dst0x, .src0x, .src0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .movhl, .tmp0x, .src0x, .src0x, ._ },
                            .{ ._, .v_sd, .add, .dst0x, .src0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse3, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .h_pd, .add, .dst0x, .src0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .xor, .tmp0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._sd, .add, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vh_pd, .add, .tmp0x, .src0x, .src0x, ._ },
                            .{ ._, .v_f128, .extract, .dst0x, .src0y, .ui(1), ._ },
                            .{ ._, .v_sd, .add, .dst0x, .tmp0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .v_sd, .add, .tmp0x, .src0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .movhl, .dst0x, .src0x, .src0x, ._ },
                            .{ ._, .v_sd, .add, .dst0x, .tmp0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .vh_pd, .add, .dst0y, .src0y, .src0y, ._ },
                            .{ ._, .v_f128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_sd, .add, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .v_pd, .add, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp0x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_sd, .add, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .zword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_pd, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_pd, .mova, .tmp2y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, .v_pd, .@"and", .dst0y, .dst0y, .mem(.src0y), ._ },
                            .{ ._, .v_pd, .@"and", .tmp2y, .tmp2y, .memd(.src0y, 32), ._ },
                            .{ ._, .v_pd, .add, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_pd, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp2x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_sd, .add, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .zword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_pd, .mova, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .v_pd, .mova, .tmp0y, .memd(.src0y, 32), ._, ._ },
                            .{ ._, .v_pd, .add, .dst0y, .dst0y, .tmp0y, ._ },
                            .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_pd, .add, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp0x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_sd, .add, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_pd, .mova, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                            .{ .@"0:", .v_pd, .add, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vh_pd, .add, .dst0y, .dst0y, .dst0y, ._ },
                            .{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_sd, .add, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_pd, .mova, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                            .{ .@"0:", .v_pd, .add, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_pd, .add, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp1x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_sd, .add, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse3, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._pd, .mova, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._pd, .add, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .h_pd, .add, .dst0x, .dst0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._pd, .mova, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._pd, .add, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, ._sd, .add, .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .zword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_pd, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_pd, .mova, .tmp2y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ },
                            .{ ._, .v_pd, .@"and", .tmp2y, .tmp2y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_pd, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                            .{ .@"0:", .v_pd, .add, .tmp2y, .tmp2y, .memid(.src0y, .tmp0, 32), ._ },
                            .{ ._, .v_pd, .add, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_pd, .add, .dst0y, .dst0y, .tmp2y, ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_pd, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp2x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_sd, .add, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_pd, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_pd, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_pd, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ .@"0:", .v_pd, .add, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .vh_pd, .add, .dst0x, .dst0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_pd, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_pd, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_pd, .add, .dst0x, .dst0x, .tmp2x, ._ },
                            .{ .@"0:", .v_pd, .add, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_ps, .movhl, .tmp2x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_sd, .add, .dst0x, .dst0x, .tmp2x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse3, .fast_hops, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._pd, .mova, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ ._, ._pd, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ .@"0:", ._pd, .add, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .h_pd, .add, .dst0x, .dst0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._pd, .mova, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ ._, ._pd, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ .@"0:", ._pd, .add, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._ps, .xor, .tmp2x, .tmp2x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp2x, .dst0x, ._, ._ },
                            .{ ._, ._sd, .add, .dst0x, .tmp2x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .x87, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f64, .kind = .{ .reg = .st7 } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .f_, .ld, .memad(.src0q, .add_unaligned_size, -8), ._, ._, ._ },
                            .{ .@"0:", .f_, .add, .memi(.src0q, .tmp0), ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
                        } },
                    }, .{
                        .required_abi = .gnu,
                        .required_features = .{ .x87, null, null, null },
                        .dst_constraints = .{ .{ .float = .tbyte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .f80, .kind = .{ .reg = .st7 } },
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f80, .kind = .{ .reg = .st6 } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .x87 }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, .f_, .ld, .memad(.src0t, .add_unaligned_size, -16), ._, ._, ._ },
                            .{ ._, ._, .mov, .tmp1d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ .@"0:", .f_, .ld, .memi(.src0t, .tmp1), ._, ._, ._ },
                            .{ ._, .f_p, .add, ._, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp1d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                        } },
                    }, .{
                        .required_abi = .msvc,
                        .required_features = .{ .x87, null, null, null },
                        .dst_constraints = .{ .{ .float = .tbyte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .f80, .kind = .{ .reg = .st7 } },
                            .{ .type = .u16, .kind = .mem },
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f80, .kind = .{ .reg = .st6 } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .x87 }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, .f_, .ld, .mem(.src0t), ._, ._, ._ },
                            .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
                            .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
                            .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_00_11), ._, ._ },
                            .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                            .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
                            .{ ._, ._, .mov, .tmp2p, .sia(16, .src0, .sub_unaligned_size), ._, ._ },
                            .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp2, .add_unaligned_size), ._, ._, ._ },
                            .{ ._, .f_p, .add, ._, ._, ._, ._ },
                            .{ ._, ._, .add, .tmp2p, .si(16), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                            .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._ps, .mova, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                            .{ .type = .f128, .kind = .mem },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp2p, .memi(.src0, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.tmp4), ._, ._ },
                            .{ ._, .v_dqa, .mov, .lea(.tmp1x), .dst0x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                            .{ .type = .f128, .kind = .mem },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp2p, .memi(.src0, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.tmp4), ._, ._ },
                            .{ ._, ._dqa, .mov, .lea(.tmp1x), .dst0x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } },
                            .{ .type = .f128, .kind = .mem },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp2p, .memi(.src0, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.tmp4), ._, ._ },
                            .{ ._, ._ps, .mova, .lea(.tmp1x), .dst0x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    } },
                    .Mul => comptime &.{ .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .dword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .mul, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ss, .mul, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .mul, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .qword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .mul, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .mul, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_f16, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = 1.0 } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"or", .dst0x, .src0x, .lea(.tmp0x), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .mul, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .mul, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .mul, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .mem, .none, .none } },
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .mul, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .mul, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .mul, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_f16, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = 1.0 } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp3y, .tmp3x, ._, ._ },
                            .{ ._, .v_ps, .mul, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .mul, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .mul, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .mul, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp0y, .tmp0x, ._, ._ },
                            .{ ._, .v_ps, .mul, .dst0y, .dst0y, .tmp0y, ._ },
                            .{ ._, .v_f128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .mul, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .mul, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .mul, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .zword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_32_f16, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = 1.0 } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_ps, .mova, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"and", .tmp3y, .tmp3y, .memd(.src0y, 32), ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .mem(.src0y), ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_ps, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, .v_f128, .extract, .tmp4x, .tmp3y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp3y, .tmp3x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp4y, .tmp4x, ._, ._ },
                            .{ ._, .v_ps, .mul, .tmp3y, .tmp3y, .tmp4y, ._ },
                            .{ ._, .v_f128, .extract, .tmp4x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp4y, .tmp4x, ._, ._ },
                            .{ ._, .v_ps, .mul, .dst0y, .dst0y, .tmp4y, ._ },
                            .{ ._, .v_ps, .mul, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .mul, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .mul, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .mul, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .zword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .mova, .tmp0y, .memd(.src0y, 32), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp1x, .tmp0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp0y, .tmp0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp1y, .tmp1x, ._, ._ },
                            .{ ._, .v_ps, .mul, .tmp0y, .tmp0y, .tmp1y, ._ },
                            .{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp1y, .tmp1x, ._, ._ },
                            .{ ._, .v_ps, .mul, .dst0y, .dst0y, .tmp1y, ._ },
                            .{ ._, .v_ps, .mul, .dst0y, .dst0y, .tmp0y, ._ },
                            .{ ._, .v_f128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .mul, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .mul, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .mul, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_float = .{ .of = .xword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .v_ps, .mul, .dst0y, .dst0y, .tmp1y, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .mul, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .mul, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .mul, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .zword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_32_f16, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = 1.0 } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_ps, .mova, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"and", .tmp3y, .tmp3y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_ps, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-80, .src0, .add_size), ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp4x, .tmp3y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp3y, .tmp3x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp4y, .tmp4x, ._, ._ },
                            .{ ._, .v_ps, .mul, .tmp3y, .tmp3y, .tmp4y, ._ },
                            .{ ._, .v_f128, .extract, .tmp4x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp4y, .tmp4x, ._, ._ },
                            .{ ._, .v_ps, .mul, .dst0y, .dst0y, .tmp4y, ._ },
                            .{ ._, .v_ps, .mul, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ .@"0:", .v_ps, .cvtph2, .tmp3y, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .v_ps, .mul, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .mul, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .mul, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .mul, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .f16c, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_f16, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = 1.0 } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
                            .{ ._, .v_ps, .cvtph2, .tmp3y, .tmp3x, ._, ._ },
                            .{ ._, .v_ps, .mul, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ .@"0:", .v_ps, .cvtph2, .tmp3y, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, .v_ps, .mul, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .mul, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b11_10) },
                            .{ ._, .v_ps, .mul, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .mul, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__mulhf3" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, .vp_, .xor, .dst0x, .dst0x, .dst0x, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .vp_w, .insr, .dst0x, .dst0x, .memad(.src0w, .add_unaligned_size, -2), .ui(0) },
                            .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ },
                            .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__mulhf3" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, .p_, .xor, .dst0x, .dst0x, ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .p_w, .insr, .dst0x, .memad(.src0w, .add_unaligned_size, -2), .ui(0), ._ },
                            .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                            .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .word }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f16, .kind = .{ .reg = .ax } },
                            .{ .type = .f32, .kind = .mem },
                            .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__mulhf3" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .movzx, .tmp1d, .memad(.src0w, .add_unaligned_size, -2), ._, ._ },
                            .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                            .{ ._, ._ss, .mov, .dst0x, .mem(.tmp2d), ._, ._ },
                            .{ .@"0:", ._ps, .xor, .tmp3x, .tmp3x, ._, ._ },
                            .{ ._, ._ss, .mov, .tmp3x, .memi(.src0d, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .shuf, .tmp0x, .src0x, .src0x, .ui(0b01) },
                            .{ ._, .v_ss, .mul, .dst0x, .src0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .qword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .mova, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .tmp0x, .tmp0x, .ui(0b01), ._ },
                            .{ ._, ._ss, .mul, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .movhl, .tmp0x, .src0x, .src0x, ._ },
                            .{ ._, .v_ss, .mul, .tmp0x, .src0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .dst0x, .src0x, .src0x, .ui(0b01) },
                            .{ ._, .v_ss, .mul, .dst0x, .tmp0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .xor, .tmp0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._ss, .mul, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .dst0x, .src0x, .ui(0b01), ._ },
                            .{ ._, ._ss, .mul, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .movhl, .tmp0x, .src0x, .src0x, ._ },
                            .{ ._, .v_ps, .mul, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .mul, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .xor, .tmp0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._ps, .mul, .dst0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .mova, .tmp0x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .tmp0x, .tmp0x, .ui(0b01), ._ },
                            .{ ._, ._ss, .mul, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_f32, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = 1.0 } } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .mul, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp3x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .mul, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .mul, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .v_ps, .mul, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp0x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .mul, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .mul, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .zword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_f32, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = 1.0 } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_ps, .mova, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .mem(.src0y), ._ },
                            .{ ._, .v_ps, .@"and", .tmp3y, .tmp3y, .memd(.src0y, 32), ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_ps, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, .v_ps, .mul, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .mul, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp3x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .mul, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .mul, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .zword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .mova, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .v_ps, .mova, .tmp0y, .memd(.src0y, 32), ._, ._ },
                            .{ ._, .v_ps, .mul, .dst0y, .dst0y, .tmp0y, ._ },
                            .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .mul, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp0x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .mul, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .mul, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                            .{ .@"0:", .v_ps, .mul, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .mul, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp1x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .mul, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .mul, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._ps, .mova, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._ps, .mul, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .mul, .dst0x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .mova, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .tmp1x, .tmp1x, .ui(0b01), ._ },
                            .{ ._, ._ss, .mul, .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .zword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_16_f32, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = 1.0 } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_ps, .mova, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"and", .tmp3y, .tmp3y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_ps, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ },
                            .{ .@"0:", .v_ps, .mul, .tmp3y, .tmp3y, .memid(.src0y, .tmp0, 32), ._ },
                            .{ ._, .v_ps, .mul, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_ps, .mul, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .mul, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp3x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .mul, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .mul, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_f32, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = 1.0 } } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_ps, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_ps, .mul, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ .@"0:", .v_ps, .mul, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_ps, .movhl, .tmp3x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_ps, .mul, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .shuf, .tmp3x, .dst0x, .dst0x, .ui(0b01) },
                            .{ ._, .v_ss, .mul, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .dword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_f32, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = 1.0 } } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._ps, .mova, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, ._ps, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, ._ps, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ .@"0:", ._ps, .mul, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._ps, .xor, .tmp3x, .tmp3x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp3x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .mul, .dst0x, .tmp3x, ._, ._ },
                            .{ ._, ._ps, .mova, .tmp3x, .dst0x, ._, ._ },
                            .{ ._, ._ps, .shuf, .tmp3x, .tmp3x, .ui(0b01), ._ },
                            .{ ._, ._ss, .mul, .dst0x, .tmp3x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_ps, .movhl, .tmp0x, .src0x, .src0x, ._ },
                            .{ ._, .v_sd, .mul, .dst0x, .src0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mut_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._ps, .xor, .tmp0x, .tmp0x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp0x, .src0x, ._, ._ },
                            .{ ._, ._sd, .mul, .dst0x, .tmp0x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .v_sd, .mul, .tmp0x, .src0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .movhl, .dst0x, .src0x, .src0x, ._ },
                            .{ ._, .v_sd, .mul, .dst0x, .tmp0x, .dst0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_sse, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
                            .{ ._, .v_pd, .mul, .dst0x, .src0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp0x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_sd, .mul, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exclusive_scalar_float = .{ .of = .zword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_f64, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = 1.0 } } },
                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_pd, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_pd, .mova, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_pd, .@"and", .dst0y, .dst0y, .mem(.src0y), ._ },
                            .{ ._, .v_pd, .@"and", .tmp3y, .tmp3y, .memd(.src0y, 32), ._ },
                            .{ ._, .v_pd, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_pd, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, .v_pd, .mul, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_i128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_pd, .mul, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp3x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_sd, .mul, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .exact_scalar_float = .{ .of = .zword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .each = .{ .once = &.{
                            .{ ._, .v_pd, .mova, .dst0y, .mem(.src0y), ._, ._ },
                            .{ ._, .v_pd, .mova, .tmp0y, .memd(.src0y, 32), ._, ._ },
                            .{ ._, .v_pd, .mul, .dst0y, .dst0y, .tmp0y, ._ },
                            .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_pd, .mul, .dst0x, .dst0x, .tmp0x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp0x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_sd, .mul, .dst0x, .dst0x, .tmp0x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_pd, .mova, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
                            .{ .@"0:", .v_pd, .mul, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_pd, .mul, .dst0x, .dst0x, .tmp1x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp1x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_sd, .mul, .dst0x, .dst0x, .tmp1x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .unaligned_multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._pd, .mova, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._pd, .mul, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp1x, .dst0x, ._, ._ },
                            .{ ._, ._sd, .mul, .dst0x, .tmp1x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx512f, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .zword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_8_f64, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = 1.0 } } },
                            .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_pd, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, .v_pd, .mova, .tmp3y, .lead(.tmp0y, 32), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_pd, .@"and", .tmp3y, .tmp3y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_pd, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
                            .{ ._, .v_pd, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, .v_pd, .@"or", .tmp3y, .tmp3y, .lead(.tmp0y, 32), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ },
                            .{ .@"0:", .v_pd, .mul, .tmp3y, .tmp3y, .memid(.src0y, .tmp0, 32), ._ },
                            .{ ._, .v_pd, .mul, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_pd, .mul, .dst0y, .dst0y, .tmp3y, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_pd, .mul, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ ._, .v_ps, .movhl, .tmp3x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_sd, .mul, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_4_f64, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = 1.0 } } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, .v_pd, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, .v_pd, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
                            .{ ._, .v_pd, .@"or", .dst0y, .dst0y, .lea(.tmp0y), ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
                            .{ ._, .v_f128, .extract, .tmp3x, .dst0y, .ui(1), ._ },
                            .{ ._, .v_pd, .mul, .dst0x, .dst0x, .tmp3x, ._ },
                            .{ .@"0:", .v_pd, .mul, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .v_ps, .movhl, .tmp3x, .dst0x, .dst0x, ._ },
                            .{ ._, .v_sd, .mul, .dst0x, .dst0x, .tmp3x, ._ },
                        } },
                    }, .{
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
                            .{ .type = .vector_2_f64, .kind = .{ .splat_float_mem = .{ .ref = .src0, .outside = 1.0 } } },
                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .sse }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                            .{ ._, ._pd, .mova, .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                            .{ ._, ._pd, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
                            .{ ._, ._pd, .@"or", .dst0x, .lea(.tmp0x), ._, ._ },
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                            .{ .@"0:", ._pd, .mul, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, ._ps, .xor, .tmp3x, .tmp3x, ._, ._ },
                            .{ ._, ._ps, .movhl, .tmp3x, .dst0x, ._, ._ },
                            .{ ._, ._sd, .mul, .dst0x, .tmp3x, ._, ._ },
                        } },
                    }, .{
                        .required_features = .{ .x87, null, null, null },
                        .dst_constraints = .{ .{ .float = .qword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f64, .kind = .{ .reg = .st7 } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .mem, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .f_, .ld, .memad(.src0q, .add_unaligned_size, -8), ._, ._, ._ },
                            .{ .@"0:", .f_, .mul, .memi(.src0q, .tmp0), ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
                        } },
                    }, .{
                        .required_abi = .gnu,
                        .required_features = .{ .x87, null, null, null },
                        .dst_constraints = .{ .{ .float = .tbyte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f80, .kind = .{ .reg = .st7 } },
                            .{ .type = .f80, .kind = .{ .reg = .st6 } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .x87 }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .f_, .ld, .memad(.src0t, .add_unaligned_size, -16), ._, ._, ._ },
                            .{ .@"0:", .f_, .ld, .memi(.src0t, .tmp0), ._, ._, ._ },
                            .{ ._, .f_p, .mul, ._, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                        } },
                    }, .{
                        .required_abi = .msvc,
                        .required_features = .{ .x87, null, null, null },
                        .dst_constraints = .{ .{ .float = .tbyte }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .extra_temps = .{
                            .{ .type = .f80, .kind = .{ .reg = .st7 } },
                            .{ .type = .u16, .kind = .mem },
                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f80, .kind = .{ .reg = .st6 } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .rc = .x87 }, .unused },
                        .clobbers = .{ .eflags = true },
                        .each = .{ .once = &.{
                            .{ ._, .f_, .ld, .mem(.src0t), ._, ._, ._ },
                            .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ },
                            .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ },
                            .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_00_11), ._, ._ },
                            .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                            .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ },
                            .{ ._, ._, .mov, .tmp2p, .sia(16, .src0, .sub_unaligned_size), ._, ._ },
                            .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp2, .add_unaligned_size), ._, ._, ._ },
                            .{ ._, .f_p, .mul, ._, ._, ._, ._ },
                            .{ ._, ._, .add, .tmp2p, .si(16), ._, ._ },
                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
                            .{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
                            .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, .v_dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .sysv64,
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._ps, .mova, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .required_features = .{ .avx, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } },
                            .{ .type = .f128, .kind = .mem },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp2p, .memi(.src0, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.tmp4), ._, ._ },
                            .{ ._, .v_dqa, .mov, .lea(.tmp1x), .dst0x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .required_features = .{ .sse2, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } },
                            .{ .type = .f128, .kind = .mem },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp2p, .memi(.src0, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.tmp4), ._, ._ },
                            .{ ._, ._dqa, .mov, .lea(.tmp1x), .dst0x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    }, .{
                        .required_cc_abi = .win64,
                        .required_features = .{ .sse, null, null, null },
                        .dst_constraints = .{ .{ .float = .xword }, .any },
                        .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any },
                        .patterns = &.{
                            .{ .src = .{ .to_mem, .none, .none } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                            .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                            .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } },
                            .{ .type = .f128, .kind = .mem },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .memad(.src0, .add_unaligned_size, -16), ._, ._ },
                            .{ .@"0:", ._, .lea, .tmp2p, .memi(.src0, .tmp0), ._, ._ },
                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                            .{ ._, ._, .lea, .tmp1p, .mem(.tmp4), ._, ._ },
                            .{ ._, ._ps, .mova, .lea(.tmp1x), .dst0x, ._, ._ },
                            .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                            .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                        } },
                    } },
                }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s}.{s} {f} {f}", .{
                        @tagName(air_tag),
                        @tagName(reduce.operation),
                        cg.typeOf(reduce.operand).fmt(pt),
                        ops[0].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{reduce.operand}, &ops, cg);
            },
            .splat => |air_tag| fallback: {
                const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                if (cg.typeOf(ty_op.operand).toIntern() == .bool_type) break :fallback try cg.airSplat(inst);
                var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                var res: [1]Temp = undefined;
                cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{
                    .required_features = .{ .avx2, null, null, null },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .byte } }, .any },
                    .src_constraints = .{ .{ .int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_b, .broadcast, .dst0x, .src0b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .byte } }, .any },
                    .src_constraints = .{ .{ .int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_, .xor, .tmp0x, .tmp0x, .tmp0x, ._ },
                        .{ ._, .vp_b, .shuf, .dst0x, .src0x, .tmp0x, ._ },
                    } },
                }, .{
                    .required_features = .{ .ssse3, null, null, null },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .byte } }, .any },
                    .src_constraints = .{ .{ .int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ },
                        .{ ._, .p_b, .shuf, .dst0x, .tmp0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .byte } }, .any },
                    .src_constraints = .{ .{ .int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_, .unpcklbw, .src0x, .src0x, ._, ._ },
                        .{ ._, .p_w, .shufl, .dst0x, .src0x, .ui(0b00_00_00_00), ._ },
                        .{ ._, .p_d, .shuf, .dst0x, .dst0x, .ui(0b00_00_00_00), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .byte } }, .any },
                    .src_constraints = .{ .{ .int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_b, .broadcast, .dst0y, .src0b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .byte } }, .any },
                    .src_constraints = .{ .{ .int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_32_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-32, .dst0, .add_size), ._, ._ },
                        .{ ._, .vp_b, .broadcast, .tmp1y, .src0b, ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .memi(.dst0y, .tmp0), .tmp1y, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .byte } }, .any },
                    .src_constraints = .{ .{ .int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_, .xor, .tmp0x, .tmp0x, .tmp0x, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ ._, .vp_b, .shuf, .tmp2x, .src0x, .tmp0x, ._ },
                        .{ .@"0:", .v_dqa, .mov, .memi(.dst0x, .tmp1), .tmp2x, ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(16), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .ssse3, null, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .byte } }, .any },
                    .src_constraints = .{ .{ .int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ ._, .p_b, .shuf, .src0x, .tmp0x, ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .memi(.dst0x, .tmp1), .src0x, ._, ._ },
                        .{ ._, ._, .sub, .tmp1d, .si(16), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .byte } }, .any },
                    .src_constraints = .{ .{ .int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_, .unpcklbw, .src0x, .src0x, ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ ._, .p_w, .shufl, .src0x, .src0x, .ui(0b00_00_00_00), ._ },
                        .{ ._, .p_d, .shuf, .src0x, .src0x, .ui(0b00_00_00_00), ._ },
                        .{ .@"0:", ._dqa, .mov, .memi(.dst0x, .tmp0), .src0x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .slow_incdec, null, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .src_constraints = .{ .{ .int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .memi(.dst0b, .tmp0), .src0b, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any },
                    .src_constraints = .{ .{ .int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .memi(.dst0b, .tmp0), .src0b, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .dst_constraints = .{ .{ .scalar = .{ .of = .xword, .is = .word } }, .any },
                    .src_constraints = .{ .{ .int_or_float = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .broadcast, .dst0x, .src0w, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .dst_constraints = .{ .{ .scalar = .{ .of = .xword, .is = .word } }, .any },
                    .src_constraints = .{ .{ .int_or_float = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_splat_mem = .{ .size = .word } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_b, .shuf, .dst0x, .src0x, .lea(.tmp0x), ._ },
                    } },
                }, .{
                    .required_features = .{ .ssse3, null, null, null },
                    .dst_constraints = .{ .{ .scalar = .{ .of = .xword, .is = .word } }, .any },
                    .src_constraints = .{ .{ .int_or_float = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_splat_mem = .{ .size = .word } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_b, .shuf, .dst0x, .lea(.tmp0x), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .dst_constraints = .{ .{ .scalar = .{ .of = .xword, .is = .word } }, .any },
                    .src_constraints = .{ .{ .int_or_float = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_w, .shufl, .dst0x, .src0x, .ui(0b00_00_00_00), ._ },
                        .{ ._, .p_d, .shuf, .dst0x, .dst0x, .ui(0b00_00_00_00), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .dst_constraints = .{ .{ .scalar = .{ .of = .yword, .is = .word } }, .any },
                    .src_constraints = .{ .{ .int_or_float = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .broadcast, .dst0y, .src0w, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar = .{ .of = .yword, .is = .word } }, .any },
                    .src_constraints = .{ .{ .int_or_float = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-32, .dst0, .add_size), ._, ._ },
                        .{ ._, .vp_w, .broadcast, .tmp1y, .src0w, ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .memi(.dst0y, .tmp0), .tmp1y, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar = .{ .of = .xword, .is = .word } }, .any },
                    .src_constraints = .{ .{ .int_or_float = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_splat_mem = .{ .size = .word } } },
                        .{ .type = .vector_8_u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .vp_b, .shuf, .tmp2x, .src0x, .lea(.tmp0x), ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp2x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .ssse3, null, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar = .{ .of = .xword, .is = .word } }, .any },
                    .src_constraints = .{ .{ .int_or_float = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_16_u8, .kind = .{ .pshufb_splat_mem = .{ .size = .word } } },
                        .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                        .{ ._, .p_b, .shuf, .src0x, .lea(.tmp0x), ._, ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .memi(.dst0x, .tmp0), .src0x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar = .{ .of = .xword, .is = .word } }, .any },
                    .src_constraints = .{ .{ .int_or_float = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_w, .shufl, .src0x, .src0x, .ui(0b00_00_00_00), ._ },
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ ._, .p_d, .shuf, .src0x, .src0x, .ui(0b00_00_00_00), ._ },
                        .{ .@"0:", ._dqa, .mov, .memi(.dst0x, .tmp0), .src0x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .dst_constraints = .{ .{ .multiple_scalar = .{ .of = .word, .is = .word } }, .any },
                    .src_constraints = .{ .{ .int_or_float = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .memi(.dst0w, .tmp0), .src0w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any },
                    .src_constraints = .{ .{ .int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .broadcast, .dst0x, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any },
                    .src_constraints = .{ .{ .float = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ss, .broadcast, .dst0x, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .dst_constraints = .{ .{ .scalar = .{ .of = .xword, .is = .dword } }, .any },
                    .src_constraints = .{ .{ .int_or_float = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ss, .broadcast, .dst0x, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any },
                    .src_constraints = .{ .{ .int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .shuf, .dst0x, .src0x, .ui(0b00_00_00_00), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any },
                    .src_constraints = .{ .{ .float = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .shuf, .dst0x, .src0x, .src0x, .ui(0b00_00_00_00) },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any },
                    .src_constraints = .{ .{ .int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_d, .shuf, .dst0x, .src0x, .ui(0b00_00_00_00), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any },
                    .src_constraints = .{ .{ .float = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._ps, .shuf, .dst0x, .src0x, .ui(0b00_00_00_00), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any },
                    .src_constraints = .{ .{ .float = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_d, .shuf, .dst0x, .src0x, .ui(0b00_00_00_00), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .dst_constraints = .{ .{ .scalar = .{ .of = .xword, .is = .dword } }, .any },
                    .src_constraints = .{ .{ .int_or_float = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._ps, .shuf, .dst0x, .src0x, .ui(0b00_00_00_00), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any },
                    .src_constraints = .{ .{ .int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_d, .broadcast, .dst0y, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .dword } }, .any },
                    .src_constraints = .{ .{ .float = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ss, .broadcast, .dst0y, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .dword } }, .any },
                    .src_constraints = .{ .{ .int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_u32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-32, .dst0, .add_size), ._, ._ },
                        .{ ._, .vp_d, .broadcast, .tmp1y, .src0d, ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .memi(.dst0y, .tmp0), .tmp1y, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, .any },
                    .src_constraints = .{ .{ .float = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-32, .dst0, .add_size), ._, ._ },
                        .{ ._, .v_ss, .broadcast, .tmp1y, .src0d, ._, ._ },
                        .{ .@"0:", .v_ps, .mova, .memi(.dst0y, .tmp0), .tmp1y, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar = .{ .of = .xword, .is = .dword } }, .any },
                    .src_constraints = .{ .{ .int_or_float = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ ._, .v_ss, .broadcast, .tmp1x, .src0d, ._, ._ },
                        .{ .@"0:", .v_ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any },
                    .src_constraints = .{ .{ .int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ ._, .vp_d, .shuf, .tmp1x, .src0x, .ui(0b00_00_00_00), ._ },
                        .{ .@"0:", .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any },
                    .src_constraints = .{ .{ .float = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_f32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ ._, .v_ps, .shuf, .tmp1x, .src0x, .src0x, .ui(0b00_00_00_00) },
                        .{ .@"0:", .v_ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any },
                    .src_constraints = .{ .{ .int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ ._, .p_d, .shuf, .tmp1x, .src0x, .ui(0b00_00_00_00), ._ },
                        .{ .@"0:", ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any },
                    .src_constraints = .{ .{ .float = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ ._, ._ps, .shuf, .src0x, .src0x, .ui(0b00_00_00_00), ._ },
                        .{ .@"0:", ._ps, .mova, .memi(.dst0x, .tmp0), .src0x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any },
                    .src_constraints = .{ .{ .float = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ ._, .p_d, .shuf, .tmp1x, .src0x, .ui(0b00_00_00_00), ._ },
                        .{ .@"0:", ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar = .{ .of = .xword, .is = .dword } }, .any },
                    .src_constraints = .{ .{ .int_or_float = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ ._, ._ps, .shuf, .src0x, .src0x, .ui(0b00_00_00_00), ._ },
                        .{ .@"0:", ._ps, .mova, .memi(.dst0x, .tmp0), .src0x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .dst_constraints = .{ .{ .multiple_scalar = .{ .of = .dword, .is = .dword } }, .any },
                    .src_constraints = .{ .{ .int_or_float = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .memi(.dst0d, .tmp0), .src0d, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .qword } }, .any },
                    .src_constraints = .{ .{ .int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_q, .broadcast, .dst0x, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any },
                    .src_constraints = .{ .{ .float = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_, .movddup, .dst0x, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .dst_constraints = .{ .{ .scalar = .{ .of = .xword, .is = .qword } }, .any },
                    .src_constraints = .{ .{ .int_or_float = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_, .movddup, .dst0x, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse3, null, null, null },
                    .dst_constraints = .{ .{ .scalar = .{ .of = .xword, .is = .qword } }, .any },
                    .src_constraints = .{ .{ .int_or_float = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movddup, .dst0x, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .qword } }, .any },
                    .src_constraints = .{ .{ .int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_d, .shuf, .dst0x, .src0x, .ui(0b01_00_01_00), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any },
                    .src_constraints = .{ .{ .float = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._pd, .shuf, .dst0x, .src0x, .ui(0b0_0), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any },
                    .src_constraints = .{ .{ .float = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .rc = .sse }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .p_d, .shuf, .dst0x, .src0x, .ui(0b01_00_01_00), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any },
                    .src_constraints = .{ .{ .float = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._pd, .shuf, .dst0x, .src0x, .ui(0b0_0), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .dst_constraints = .{ .{ .scalar = .{ .of = .xword, .is = .qword } }, .any },
                    .src_constraints = .{ .{ .int_or_float = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._ps, .shuf, .dst0x, .src0x, .ui(0b01_00_01_00), ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .dst_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .qword } }, .any },
                    .src_constraints = .{ .{ .int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .vp_q, .broadcast, .dst0y, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .qword } }, .any },
                    .src_constraints = .{ .{ .float = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_sd, .broadcast, .dst0y, .src0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .qword } }, .any },
                    .src_constraints = .{ .{ .int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_u64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-32, .dst0, .add_size), ._, ._ },
                        .{ ._, .vp_q, .broadcast, .tmp1y, .src0q, ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .memi(.dst0y, .tmp0), .tmp1y, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any },
                    .src_constraints = .{ .{ .float = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_f64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-32, .dst0, .add_size), ._, ._ },
                        .{ ._, .v_sd, .broadcast, .tmp1y, .src0q, ._, ._ },
                        .{ .@"0:", .v_pd, .mova, .memi(.dst0y, .tmp0), .tmp1y, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar = .{ .of = .xword, .is = .qword } }, .any },
                    .src_constraints = .{ .{ .int_or_float = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_u64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ ._, .v_, .movddup, .tmp1x, .src0q, ._, ._ },
                        .{ .@"0:", .v_pd, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse3, null, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar = .{ .of = .xword, .is = .qword } }, .any },
                    .src_constraints = .{ .{ .int_or_float = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_u64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ ._, ._, .movddup, .tmp1x, .src0q, ._, ._ },
                        .{ .@"0:", ._pd, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } }, .any },
                    .src_constraints = .{ .{ .int = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_u64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ ._, .p_d, .shuf, .tmp1x, .src0x, .ui(0b01_00_01_00), ._ },
                        .{ .@"0:", ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any },
                    .src_constraints = .{ .{ .float = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ ._, ._pd, .shuf, .src0x, .src0x, .ui(0b0_0), ._ },
                        .{ .@"0:", ._pd, .mova, .memi(.dst0x, .tmp0), .src0x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any },
                    .src_constraints = .{ .{ .float = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ ._, .p_d, .shuf, .tmp1x, .src0x, .ui(0b01_00_01_00), ._ },
                        .{ .@"0:", ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any },
                    .src_constraints = .{ .{ .float = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ ._, ._pd, .shuf, .src0x, .src0x, .ui(0b0_0), ._ },
                        .{ .@"0:", ._pd, .mova, .memi(.dst0x, .tmp0), .src0x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar = .{ .of = .xword, .is = .qword } }, .any },
                    .src_constraints = .{ .{ .int_or_float = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ ._, ._ps, .shuf, .src0x, .src0x, .ui(0b01_00_01_00), ._ },
                        .{ .@"0:", ._ps, .mova, .memi(.dst0x, .tmp0), .src0x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar = .{ .of = .qword, .is = .qword } }, .any },
                    .src_constraints = .{ .{ .int_or_float = .qword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .memi(.dst0q, .tmp0), .src0q, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .dst_constraints = .{ .{ .scalar = .{ .of = .yword, .is = .xword } }, .any },
                    .src_constraints = .{ .{ .int_or_float = .xword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_i128, .broadcast, .dst0y, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .dst_constraints = .{ .{ .scalar = .{ .of = .yword, .is = .xword } }, .any },
                    .src_constraints = .{ .{ .int_or_float = .xword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_i128, .insert, .dst0y, .src0y, .src0x, .ui(1) },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .dst_constraints = .{ .{ .scalar = .{ .of = .yword, .is = .xword } }, .any },
                    .src_constraints = .{ .{ .int_or_float = .xword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_f128, .broadcast, .dst0y, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .dst_constraints = .{ .{ .scalar = .{ .of = .yword, .is = .xword } }, .any },
                    .src_constraints = .{ .{ .int_or_float = .xword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_f128, .insert, .dst0y, .src0y, .src0x, .ui(1) },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar = .{ .of = .yword, .is = .xword } }, .any },
                    .src_constraints = .{ .{ .int_or_float = .xword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_u128, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-32, .dst0, .add_size), ._, ._ },
                        .{ ._, .v_i128, .broadcast, .tmp1y, .src0x, ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .memi(.dst0y, .tmp0), .tmp1y, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar = .{ .of = .yword, .is = .xword } }, .any },
                    .src_constraints = .{ .{ .int_or_float = .xword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_u128, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-32, .dst0, .add_size), ._, ._ },
                        .{ ._, .v_i128, .insert, .tmp1y, .src0y, .src0x, .ui(1) },
                        .{ .@"0:", .v_dqa, .mov, .memi(.dst0y, .tmp0), .tmp1y, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar = .{ .of = .yword, .is = .xword } }, .any },
                    .src_constraints = .{ .{ .int_or_float = .xword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_f64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-32, .dst0, .add_size), ._, ._ },
                        .{ ._, .v_f128, .broadcast, .tmp1y, .src0x, ._, ._ },
                        .{ .@"0:", .v_pd, .mova, .memi(.dst0y, .tmp0), .tmp1y, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar = .{ .of = .yword, .is = .xword } }, .any },
                    .src_constraints = .{ .{ .int_or_float = .xword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_f64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-32, .dst0, .add_size), ._, ._ },
                        .{ ._, .v_f128, .insert, .tmp1y, .src0y, .src0x, .ui(1) },
                        .{ .@"0:", .v_pd, .mova, .memi(.dst0y, .tmp0), .tmp1y, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar = .{ .of = .xword, .is = .xword } }, .any },
                    .src_constraints = .{ .{ .int_or_float = .xword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .memi(.dst0x, .tmp0), .src0x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar = .{ .of = .xword, .is = .xword } }, .any },
                    .src_constraints = .{ .{ .int_or_float = .xword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .memi(.dst0x, .tmp0), .src0x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar = .{ .of = .xword, .is = .xword } }, .any },
                    .src_constraints = .{ .{ .int_or_float = .xword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .memi(.dst0x, .tmp0), .src0x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx2, null, null },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .tbyte } }, .any },
                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_i128, .broadcast, .dst0y, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx2, null, null },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .tbyte } }, .any },
                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_i128, .insert, .dst0y, .src0y, .src0x, .ui(1) },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .tbyte } }, .any },
                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_f128, .broadcast, .dst0y, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .dst_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .tbyte } }, .any },
                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .none, .none } },
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_f128, .insert, .dst0y, .src0y, .src0x, .ui(1) },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx2, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .tbyte } }, .any },
                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_2_u128, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-32, .dst0, .add_size), ._, ._ },
                        .{ ._, .v_i128, .broadcast, .tmp1y, .src0x, ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .memi(.dst0y, .tmp0), .tmp1y, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .tbyte } }, .any },
                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_f64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-32, .dst0, .add_size), ._, ._ },
                        .{ ._, .v_f128, .broadcast, .tmp1y, .src0x, ._, ._ },
                        .{ .@"0:", .v_pd, .mova, .memi(.dst0y, .tmp0), .tmp1y, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .avx, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp1x, .mem(.src0x), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse2, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp1x, .mem(.src0x), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .sse, null, null },
                    .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any },
                    .src_constraints = .{ .{ .float = .tbyte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ },
                        .{ ._, ._ps, .mova, .tmp1x, .mem(.src0x), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .slow_incdec, null, null },
                    .dst_constraints = .{ .{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } }, .any },
                    .src_constraints = .{ .{ .remainder_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
                        .{ .type = .usize, .kind = .{ .reg = .rcx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sa(.dst0, .add_len), ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .mem(.dst0), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp2q, .mem(.src0), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
                        .{ ._, ._a, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .dst_constraints = .{ .{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } }, .any },
                    .src_constraints = .{ .{ .remainder_int = .{ .of = .qword, .is = .qword } }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .reg = .rdi } },
                        .{ .type = .usize, .kind = .{ .reg = .rsi } },
                        .{ .type = .usize, .kind = .{ .reg = .rcx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sa(.dst0, .add_len), ._, ._ },
                        .{ ._, ._, .lea, .tmp1q, .mem(.dst0), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp2q, .mem(.src0), ._, ._ },
                        .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_size_div_8), ._, ._ },
                        .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
                        .{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f}", .{
                        @tagName(air_tag),
                        ty_op.ty.toType().fmt(pt),
                        ops[0].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{ty_op.operand}, &ops, cg);
            },

            .memset => try cg.airMemset(inst, false),
            .memset_safe => try cg.airMemset(inst, true),
            .memcpy, .memmove => |air_tag| {
                const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }) ++ .{undefined};
                ops[2] = ops[0].getByteLen(cg) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f} {f} {f}", .{
                        @tagName(air_tag),
                        cg.typeOf(bin_op.lhs).fmt(pt),
                        cg.typeOf(bin_op.rhs).fmt(pt),
                        ops[0].tracking(cg),
                        ops[1].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try ops[0].toSlicePtr(cg);
                cg.select(&.{}, &.{}, &ops, switch (air_tag) {
                    else => unreachable,
                    inline .memcpy, .memmove => |symbol| comptime &.{.{
                        .patterns = &.{
                            .{ .src = .{
                                .{ .to_param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } },
                                .{ .to_param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } },
                                .{ .to_param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } },
                            } },
                        },
                        .call_frame = .{ .alignment = .@"16" },
                        .extra_temps = .{
                            .{ .type = .usize, .kind = .{ .extern_func = @tagName(symbol) } },
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                            .unused,
                        },
                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                        .each = .{ .once = &.{
                            .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                        } },
                    }},
                }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f} {f} {f} {f}", .{
                        @tagName(air_tag),
                        cg.typeOf(bin_op.lhs).fmt(pt),
                        cg.typeOf(bin_op.rhs).fmt(pt),
                        ops[0].tracking(cg),
                        ops[1].tracking(cg),
                        ops[2].tracking(cg),
                    }),
                    else => |e| return e,
                };
                for (ops) |op| try op.die(cg);
            },
            .cmpxchg_weak, .cmpxchg_strong => try cg.airCmpxchg(inst),
            .atomic_load => try cg.airAtomicLoad(inst),
            .atomic_store_unordered => try cg.airAtomicStore(inst, .unordered),
            .atomic_store_monotonic => try cg.airAtomicStore(inst, .monotonic),
            .atomic_store_release => try cg.airAtomicStore(inst, .release),
            .atomic_store_seq_cst => try cg.airAtomicStore(inst, .seq_cst),
            .atomic_rmw => try cg.airAtomicRmw(inst),
            .is_named_enum_value => |air_tag| {
                const un_op = air_datas[@intFromEnum(inst)].un_op;
                var ops = try cg.tempsFromOperands(inst, .{un_op});
                var res: [1]Temp = undefined;
                cg.select(&res, &.{.bool}, &ops, comptime &.{ .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .int = .gpr }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"32" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .lazy_sym = .{ .kind = .code, .ref = .src0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .cc = .nz }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .zigcc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                        .{ ._, ._, .@"test", .src0p, .src0p, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .any_int, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"32" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .zigcc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .lazy_sym = .{ .kind = .code, .ref = .src0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .cc = .nz }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .zigcc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                        .{ ._, ._, .@"test", .tmp0p, .tmp0p, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .int = .gpr }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .lazy_sym = .{ .kind = .code, .ref = .src0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .cc = .nz }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .zigcc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                        .{ ._, ._, .@"test", .src0p, .src0p, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .any_int, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .zigcc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .lazy_sym = .{ .kind = .code, .ref = .src0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .cc = .nz }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .zigcc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                        .{ ._, ._, .@"test", .tmp0p, .tmp0p, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .int = .gpr }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"8" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .lazy_sym = .{ .kind = .code, .ref = .src0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .cc = .nz }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .zigcc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                        .{ ._, ._, .@"test", .src0p, .src0p, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .any_int, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"8" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .zigcc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .lazy_sym = .{ .kind = .code, .ref = .src0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .cc = .nz }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .zigcc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
                        .{ ._, ._, .@"test", .tmp0p, .tmp0p, ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f}", .{
                        @tagName(air_tag),
                        cg.typeOf(un_op).fmt(pt),
                        ops[0].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{un_op}, &ops, cg);
            },
            .tag_name => |air_tag| {
                const un_op = air_datas[@intFromEnum(inst)].un_op;
                var ops = try cg.tempsFromOperands(inst, .{un_op});
                var res: [1]Temp = undefined;
                cg.select(&res, &.{.slice_const_u8_sentinel_0}, &ops, comptime &.{ .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .int = .gpr }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"32" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .lazy_sym = .{ .kind = .code, .ref = .src0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_gpr = .{ .cc = .zigcc, .after = 1, .at = 1 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .zigcc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .any_int, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"32" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .lazy_sym = .{ .kind = .code, .ref = .src0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .zigcc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .zigcc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p0, .mem(.src0), ._, ._ },
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .int = .gpr }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .lazy_sym = .{ .kind = .code, .ref = .src0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_gpr = .{ .cc = .zigcc, .after = 1, .at = 1 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .zigcc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .any_int, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .lazy_sym = .{ .kind = .code, .ref = .src0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .zigcc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .zigcc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p0, .mem(.src0), ._, ._ },
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .int = .gpr }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"8" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .lazy_sym = .{ .kind = .code, .ref = .src0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_gpr = .{ .cc = .zigcc, .after = 1, .at = 1 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .zigcc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .any_int, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"8" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .lazy_sym = .{ .kind = .code, .ref = .src0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .zigcc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .zigcc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .dst0p0, .mem(.src0), ._, ._ },
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f}", .{
                        @tagName(air_tag),
                        cg.typeOf(un_op).fmt(pt),
                        ops[0].tracking(cg),
                    }),
                    else => |e| return e,
                };
                if (res[0].tracking(cg).short != .register_pair) try ops[0].toPair(&res[0], cg);
                try res[0].finish(inst, &.{un_op}, &ops, cg);
            },
            .error_name => |air_tag| {
                const un_op = air_datas[@intFromEnum(inst)].un_op;
                var ops = try cg.tempsFromOperands(inst, .{un_op});
                var res: [2]Temp = undefined;
                cg.select(&res, &.{ .slice_const_u8_sentinel_0, .usize }, &ops, comptime &.{ .{
                    .src_constraints = .{ .{ .int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .anyerror, .kind = .{ .lazy_sym = .{ .kind = .const_data } } },
                        .{ .type = .u32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .{ .rc = .general_purpose } },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp1d, .src0b, ._, ._ },
                        .{ ._, ._, .lea, .dst0p, .lea(.tmp0), ._, ._ },
                        .{ ._, ._, .mov, .dst1d, .leasid(.dst0d, .@"4", .tmp1, (2 - 1) * 4), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .leasid(.dst0d, .@"4", .tmp1, (1 - 1) * 4), ._, ._ },
                        .{ ._, ._, .lea, .dst0p, .leai(.dst0, .tmp1), ._, ._ },
                        .{ ._, ._, .not, .tmp1d, ._, ._, ._ },
                        .{ ._, ._, .lea, .dst1d, .leai(.dst1, .tmp1), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .int = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .anyerror, .kind = .{ .lazy_sym = .{ .kind = .const_data } } },
                        .{ .type = .u32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .{ .rc = .general_purpose } },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp1d, .src0w, ._, ._ },
                        .{ ._, ._, .lea, .dst0p, .lea(.tmp0), ._, ._ },
                        .{ ._, ._, .mov, .dst1d, .leasid(.dst0d, .@"4", .tmp1, (2 - 1) * 4), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .leasid(.dst0d, .@"4", .tmp1, (1 - 1) * 4), ._, ._ },
                        .{ ._, ._, .lea, .dst0p, .leai(.dst0, .tmp1), ._, ._ },
                        .{ ._, ._, .not, .tmp1d, ._, ._, ._ },
                        .{ ._, ._, .lea, .dst1d, .leai(.dst1, .tmp1), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .none, .none } },
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .anyerror, .kind = .{ .lazy_sym = .{ .kind = .const_data } } },
                        .{ .type = .u32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .rc = .general_purpose }, .{ .rc = .general_purpose } },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp1d, .src0d, ._, ._ },
                        .{ ._, ._, .lea, .dst0p, .lea(.tmp0), ._, ._ },
                        .{ ._, ._, .mov, .dst1d, .leasid(.dst0d, .@"4", .tmp1, (2 - 1) * 4), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .leasid(.dst0d, .@"4", .tmp1, (1 - 1) * 4), ._, ._ },
                        .{ ._, ._, .lea, .dst0p, .leai(.dst0, .tmp1), ._, ._ },
                        .{ ._, ._, .not, .tmp1d, ._, ._, ._ },
                        .{ ._, ._, .lea, .dst1d, .leai(.dst1, .tmp1), ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f}", .{
                        @tagName(air_tag),
                        cg.typeOf(un_op).fmt(pt),
                        ops[0].tracking(cg),
                    }),
                    else => |e| return e,
                };
                const orig_res = res;
                try res[0].toPair(&res[1], cg);
                for (&ops) |*op| for (orig_res) |orig_r| {
                    if (op.index != orig_r.index) continue;
                    op.* = res[0];
                    break;
                };
                try res[0].finish(inst, &.{un_op}, &ops, cg);
            },
            .error_set_has_value => |air_tag| {
                const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}) ++ .{try cg.tempInit(ty_op.ty.toType(), .none)};
                var res: [1]Temp = undefined;
                cg.select(&res, &.{.bool}, &ops, comptime &.{ .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .int = .gpr }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"32" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .lazy_sym = .{ .kind = .code, .ref = .src1 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .cc = .nz }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .zigcc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                        .{ ._, ._, .@"test", .src0d, .src0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .{ .int = .gpr }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .lazy_sym = .{ .kind = .code, .ref = .src1 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .cc = .nz }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .zigcc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                        .{ ._, ._, .@"test", .src0d, .src0d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .int = .gpr }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .after = 0, .at = 0 } }, .none, .none } },
                    },
                    .call_frame = .{ .alignment = .@"8" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .lazy_sym = .{ .kind = .code, .ref = .src1 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .cc = .nz }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .zigcc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                        .{ ._, ._, .@"test", .src0d, .src0d, ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f}", .{
                        @tagName(air_tag),
                        ty_op.ty.toType().fmt(pt),
                        ops[0].tracking(cg),
                    }),
                    else => |e| return e,
                };
                for (ops[1..]) |op| try op.die(cg);
                try res[0].finish(inst, &.{ty_op.operand}, ops[0..1], cg);
            },
            .aggregate_init => |air_tag| fallback: {
                const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
                const agg_ty = ty_pl.ty.toType();
                if (agg_ty.isVector(zcu) and agg_ty.childType(zcu).toIntern() == .bool_type) {
                    break :fallback try cg.airAggregateInitBoolVec(inst);
                }
                var res = try cg.tempAllocMem(agg_ty);
                const reset_index = cg.next_temp_index;
                var bt = cg.liveness.iterateBigTomb(inst);
                switch (ip.indexToKey(agg_ty.toIntern())) {
                    inline .array_type, .vector_type => |sequence_type| {
                        const elems: []const Air.Inst.Ref = @ptrCast(cg.air.extra.items[ty_pl.payload..][0..@intCast(sequence_type.len)]);
                        const elem_size = Type.fromInterned(sequence_type.child).abiSize(zcu);
                        var elem_disp: u31 = 0;
                        for (elems) |elem_ref| {
                            var elem = try cg.tempFromOperand(elem_ref, bt.feed());
                            try res.write(&elem, .{ .disp = elem_disp }, cg);
                            try elem.die(cg);
                            try cg.resetTemps(reset_index);
                            elem_disp += @intCast(elem_size);
                        }
                        if (@hasField(@TypeOf(sequence_type), "sentinel") and sequence_type.sentinel != .none) {
                            var sentinel = try cg.tempFromValue(.fromInterned(sequence_type.sentinel));
                            try res.write(&sentinel, .{ .disp = elem_disp }, cg);
                            try sentinel.die(cg);
                        }
                    },
                    .struct_type => {
                        const loaded_struct = ip.loadStructType(agg_ty.toIntern());
                        const elems: []const Air.Inst.Ref = @ptrCast(cg.air.extra.items[ty_pl.payload..][0..loaded_struct.field_types.len]);
                        switch (loaded_struct.layout) {
                            .auto, .@"extern" => {
                                for (elems, 0..) |elem_ref, field_index| {
                                    const elem_dies = bt.feed();
                                    if (loaded_struct.fieldIsComptime(ip, field_index)) continue;
                                    if (!hack_around_sema_opv_bugs or Type.fromInterned(loaded_struct.field_types.get(ip)[field_index]).hasRuntimeBitsIgnoreComptime(zcu)) {
                                        var elem = try cg.tempFromOperand(elem_ref, elem_dies);
                                        try res.write(&elem, .{ .disp = @intCast(loaded_struct.offsets.get(ip)[field_index]) }, cg);
                                        try elem.die(cg);
                                        try cg.resetTemps(reset_index);
                                    }
                                }
                            },
                            .@"packed" => unreachable,
                        }
                    },
                    .tuple_type => |tuple_type| {
                        const elems: []const Air.Inst.Ref = @ptrCast(cg.air.extra.items[ty_pl.payload..][0..tuple_type.types.len]);
                        var elem_disp: u31 = 0;
                        for (elems, 0..) |elem_ref, field_index| {
                            const elem_dies = bt.feed();
                            if (tuple_type.values.get(ip)[field_index] != .none) continue;
                            const field_type = Type.fromInterned(tuple_type.types.get(ip)[field_index]);
                            elem_disp = @intCast(field_type.abiAlignment(zcu).forward(elem_disp));
                            var elem = try cg.tempFromOperand(elem_ref, elem_dies);
                            try res.write(&elem, .{ .disp = elem_disp }, cg);
                            try elem.die(cg);
                            try cg.resetTemps(reset_index);
                            elem_disp += @intCast(field_type.abiSize(zcu));
                        }
                    },
                    else => return cg.fail("failed to select {s} {f}", .{
                        @tagName(air_tag),
                        agg_ty.fmt(pt),
                    }),
                }
                try res.finish(inst, &.{}, &.{}, cg);
            },
            .union_init => {
                const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
                const union_init = cg.air.extraData(Air.UnionInit, ty_pl.payload).data;
                const union_ty = ty_pl.ty.toType();
                var ops = try cg.tempsFromOperands(inst, .{union_init.init});
                var res = try cg.tempAllocMem(union_ty);
                const union_layout = union_ty.unionGetLayout(zcu);
                if (union_layout.tag_size > 0) {
                    var tag_temp = try cg.tempFromValue(try pt.enumValueFieldIndex(
                        union_ty.unionTagTypeSafety(zcu).?,
                        union_init.field_index,
                    ));
                    try res.write(&tag_temp, .{
                        .disp = @intCast(union_layout.tagOffset()),
                    }, cg);
                    try tag_temp.die(cg);
                }
                try res.write(&ops[0], .{
                    .disp = @intCast(union_layout.payloadOffset()),
                }, cg);
                try res.finish(inst, &.{union_init.init}, &ops, cg);
            },
            .prefetch => {
                const prefetch = air_datas[@intFromEnum(inst)].prefetch;
                var ops = try cg.tempsFromOperands(inst, .{prefetch.ptr});
                switch (prefetch.cache) {
                    .instruction => {}, // prefetchi requires rip-relative addressing, which is currently non-trivial to emit from an arbitrary ptr value
                    .data => if (prefetch.rw == .write and prefetch.locality <= 2 and cg.hasFeature(.prefetchwt1)) {
                        try ops[0].toSlicePtr(cg);
                        while (try ops[0].toLea(cg)) {}
                        try cg.asmMemory(.{ ._wt1, .prefetch }, try ops[0].tracking(cg).short.deref().mem(cg, .{ .size = .byte }));
                    } else if (prefetch.rw == .write and cg.hasFeature(.prfchw)) {
                        try ops[0].toSlicePtr(cg);
                        while (try ops[0].toLea(cg)) {}
                        try cg.asmMemory(.{ ._w, .prefetch }, try ops[0].tracking(cg).short.deref().mem(cg, .{ .size = .byte }));
                    } else if (cg.hasFeature(.sse) or cg.hasFeature(.prfchw) or cg.hasFeature(.prefetchi) or cg.hasFeature(.prefetchwt1)) {
                        try ops[0].toSlicePtr(cg);
                        while (try ops[0].toLea(cg)) {}
                        switch (prefetch.locality) {
                            0 => try cg.asmMemory(.{ ._nta, .prefetch }, try ops[0].tracking(cg).short.deref().mem(cg, .{ .size = .byte })),
                            1 => try cg.asmMemory(.{ ._t2, .prefetch }, try ops[0].tracking(cg).short.deref().mem(cg, .{ .size = .byte })),
                            2 => try cg.asmMemory(.{ ._t1, .prefetch }, try ops[0].tracking(cg).short.deref().mem(cg, .{ .size = .byte })),
                            3 => try cg.asmMemory(.{ ._t0, .prefetch }, try ops[0].tracking(cg).short.deref().mem(cg, .{ .size = .byte })),
                        }
                    },
                }
                const res = try cg.tempInit(.void, .none);
                try res.finish(inst, &.{prefetch.ptr}, &ops, cg);
            },
            .mul_add => |air_tag| {
                const pl_op = air_datas[@intFromEnum(inst)].pl_op;
                const bin_op = cg.air.extraData(Air.Bin, pl_op.payload).data;
                var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs, pl_op.operand });
                var res: [1]Temp = undefined;
                cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{
                    .required_features = .{ .fma, .f16c, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .to_sse, .to_sse } },
                    },
                    .extra_temps = .{
                        .{ .type = .f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .{ .type = .f16, .kind = .{ .mut_rc = .{ .ref = .src2, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp1x, .src2q, ._, ._ },
                        .{ ._, .v_ss, .fmadd213, .dst0x, .tmp0x, .tmp1d, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                        .{ .scalar_float = .{ .of = .word, .is = .word } },
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } },
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmah" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fma, .f16c, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .word } },
                        .{ .scalar_float = .{ .of = .qword, .is = .word } },
                        .{ .scalar_float = .{ .of = .qword, .is = .word } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .mem } },
                        .{ .src = .{ .to_sse, .mem, .mem } },
                        .{ .src = .{ .mem, .to_sse, .mem } },
                        .{ .src = .{ .mem, .mem, .to_sse } },
                        .{ .src = .{ .to_sse, .to_sse, .mem } },
                        .{ .src = .{ .to_sse, .mem, .to_sse } },
                        .{ .src = .{ .mem, .to_sse, .to_sse } },
                        .{ .src = .{ .to_sse, .to_sse, .to_sse } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_4_f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .{ .type = .vector_4_f16, .kind = .{ .mut_rc = .{ .ref = .src2, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp1x, .src2q, ._, ._ },
                        .{ ._, .v_ps, .fmadd213, .dst0x, .tmp0x, .tmp1x, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .fma, .f16c, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .word } },
                        .{ .scalar_float = .{ .of = .xword, .is = .word } },
                        .{ .scalar_float = .{ .of = .xword, .is = .word } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .mem, .mem, .mem } },
                        .{ .src = .{ .to_sse, .mem, .mem } },
                        .{ .src = .{ .mem, .to_sse, .mem } },
                        .{ .src = .{ .mem, .mem, .to_sse } },
                        .{ .src = .{ .to_sse, .to_sse, .mem } },
                        .{ .src = .{ .to_sse, .mem, .to_sse } },
                        .{ .src = .{ .mem, .to_sse, .to_sse } },
                        .{ .src = .{ .to_sse, .to_sse, .to_sse } },
                    },
                    .extra_temps = .{
                        .{ .type = .vector_8_f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .{ .type = .vector_8_f16, .kind = .{ .mut_rc = .{ .ref = .src2, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp1y, .src2x, ._, ._ },
                        .{ ._, .v_ps, .fmadd213, .dst0y, .tmp0y, .tmp1y, ._ },
                        .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
                    } },
                }, .{
                    .required_features = .{ .fma, .f16c, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .to_mem } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .{ .type = .vector_8_f16, .kind = .{ .mut_rc = .{ .ref = .src2, .rc = .sse } } },
                        .{ .type = .vector_8_f16, .kind = .{ .mut_rc = .{ .ref = .src2, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ },
                        .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp2y, .memi(.src1x, .tmp0), ._, ._ },
                        .{ ._, .v_ps, .cvtph2, .tmp3y, .memi(.src2x, .tmp0), ._, ._ },
                        .{ ._, .v_ps, .fmadd213, .tmp1y, .tmp2y, .tmp3y, ._ },
                        .{ ._, .v_, .cvtps2ph, .memi(.dst0x, .tmp0), .tmp1y, .rm(.{}), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .to_mem } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmah" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .vp_, .xor, .tmp3x, .tmp3x, .tmp3x, ._ },
                        .{ ._, .vp_w, .insr, .tmp1x, .tmp3x, .memi(.src0w, .tmp0), .ui(0) },
                        .{ ._, .vp_w, .insr, .tmp2x, .tmp3x, .memi(.src1w, .tmp0), .ui(0) },
                        .{ ._, .vp_w, .insr, .tmp3x, .tmp3x, .memi(.src2w, .tmp0), .ui(0) },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .to_mem } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmah" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp3x, .tmp3x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                        .{ ._, .p_w, .insr, .tmp2x, .memi(.src1w, .tmp0), .ui(0), ._ },
                        .{ ._, .p_w, .insr, .tmp3x, .memi(.src2w, .tmp0), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .to_mem } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmah" } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, .p_, .xor, .tmp3x, .tmp3x, ._, ._ },
                        .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ },
                        .{ ._, .p_w, .insr, .tmp2x, .memi(.src1w, .tmp0), .ui(0), ._ },
                        .{ ._, .p_w, .insr, .tmp3x, .memi(.src2w, .tmp0), .ui(0), ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, .p_w, .extr, .tmp5d, .tmp1x, .ui(0), ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp5w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .to_mem } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f16, .kind = .{ .reg = .ax } },
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmah" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .movzx, .tmp1d, .memi(.src1w, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .movzx, .tmp1d, .memi(.src2w, .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
                        .{ ._, ._ss, .mov, .tmp5x, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ },
                        .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fma, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .to_sse } },
                        .{ .src = .{ .mem, .to_mut_sse, .to_sse }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .mut_sse, .sse, .sse } },
                        .{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ss, .fmadd132, .dst0x, .src2x, .src1d, ._ },
                    } },
                }, .{
                    .required_features = .{ .fma, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .to_sse, .mem } },
                        .{ .src = .{ .to_sse, .to_mut_sse, .mem }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .mut_sse, .sse, .sse } },
                        .{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ss, .fmadd213, .dst0x, .src1x, .src2d, ._ },
                    } },
                }, .{
                    .required_features = .{ .fma, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .to_mut_sse } },
                        .{ .src = .{ .mem, .to_sse, .to_mut_sse }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .to_mut_sse } },
                    },
                    .dst_temps = .{ .{ .ref = .src2 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ss, .fmadd231, .dst0x, .src0x, .src1d, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } },
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "fmaf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fma, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .to_sse } },
                        .{ .src = .{ .mem, .to_mut_sse, .to_sse }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .mut_sse, .sse, .sse } },
                        .{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .fmadd132, .dst0x, .src2x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .fma, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .to_sse, .mem } },
                        .{ .src = .{ .to_sse, .to_mut_sse, .mem }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .mut_sse, .sse, .sse } },
                        .{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .fmadd213, .dst0x, .src1x, .src2x, ._ },
                    } },
                }, .{
                    .required_features = .{ .fma, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .to_mut_sse } },
                        .{ .src = .{ .mem, .to_sse, .to_mut_sse }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .to_mut_sse } },
                    },
                    .dst_temps = .{ .{ .ref = .src2 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .fmadd231, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .fma, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .yword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .yword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .yword, .is = .dword } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .to_sse } },
                        .{ .src = .{ .mem, .to_mut_sse, .to_sse }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .mut_sse, .sse, .sse } },
                        .{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .fmadd132, .dst0y, .src2y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .fma, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .yword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .yword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .yword, .is = .dword } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .to_sse, .mem } },
                        .{ .src = .{ .to_sse, .to_mut_sse, .mem }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .mut_sse, .sse, .sse } },
                        .{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .fmadd213, .dst0y, .src1y, .src2y, ._ },
                    } },
                }, .{
                    .required_features = .{ .fma, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .yword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .yword, .is = .dword } },
                        .{ .scalar_float = .{ .of = .yword, .is = .dword } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .to_mut_sse } },
                        .{ .src = .{ .mem, .to_sse, .to_mut_sse }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .to_mut_sse } },
                    },
                    .dst_temps = .{ .{ .ref = .src2 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_ps, .fmadd231, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .fma, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .to_mem } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src2, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                        .{ .@"0:", .v_ps, .mova, .tmp1y, .memi(.src0y, .tmp0), ._, ._ },
                        .{ ._, .v_ps, .mova, .tmp2y, .memi(.src1y, .tmp0), ._, ._ },
                        .{ ._, .v_ps, .fmadd213, .tmp1y, .tmp2y, .memi(.src2y, .tmp0), ._ },
                        .{ ._, .v_ps, .mova, .memi(.dst0y, .tmp0), .tmp1y, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .to_mem } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmaf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, .v_ss, .mov, .tmp2x, .memi(.src1d, .tmp0), ._, ._ },
                        .{ ._, .v_ss, .mov, .tmp3x, .memi(.src2d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
                        .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .to_mem } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmaf" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ },
                        .{ ._, ._ss, .mov, .tmp2x, .memi(.src1d, .tmp0), ._, ._ },
                        .{ ._, ._ss, .mov, .tmp3x, .memi(.src2d, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fma, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .to_sse } },
                        .{ .src = .{ .mem, .to_mut_sse, .to_sse }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .mut_sse, .sse, .sse } },
                        .{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_sd, .fmadd132, .dst0x, .src2x, .src1q, ._ },
                    } },
                }, .{
                    .required_features = .{ .fma, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .to_sse, .mem } },
                        .{ .src = .{ .to_sse, .to_mut_sse, .mem }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .mut_sse, .sse, .sse } },
                        .{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_sd, .fmadd213, .dst0x, .src1x, .src2q, ._ },
                    } },
                }, .{
                    .required_features = .{ .fma, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .to_mut_sse } },
                        .{ .src = .{ .mem, .to_sse, .to_mut_sse }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .to_mut_sse } },
                    },
                    .dst_temps = .{ .{ .ref = .src2 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_sd, .fmadd231, .dst0x, .src0x, .src1q, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } },
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "fma" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .fma, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .to_sse } },
                        .{ .src = .{ .mem, .to_mut_sse, .to_sse }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .mut_sse, .sse, .sse } },
                        .{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_pd, .fmadd132, .dst0x, .src2x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .fma, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .to_sse, .mem } },
                        .{ .src = .{ .to_sse, .to_mut_sse, .mem }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .mut_sse, .sse, .sse } },
                        .{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_pd, .fmadd213, .dst0x, .src1x, .src2x, ._ },
                    } },
                }, .{
                    .required_features = .{ .fma, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .to_mut_sse } },
                        .{ .src = .{ .mem, .to_sse, .to_mut_sse }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .to_mut_sse } },
                    },
                    .dst_temps = .{ .{ .ref = .src2 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_pd, .fmadd231, .dst0x, .src0x, .src1x, ._ },
                    } },
                }, .{
                    .required_features = .{ .fma, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .yword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .yword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .yword, .is = .qword } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .to_sse } },
                        .{ .src = .{ .mem, .to_mut_sse, .to_sse }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .mut_sse, .sse, .sse } },
                        .{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_pd, .fmadd132, .dst0y, .src2y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .fma, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .yword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .yword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .yword, .is = .qword } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .to_sse, .mem } },
                        .{ .src = .{ .to_sse, .to_mut_sse, .mem }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .mut_sse, .sse, .sse } },
                        .{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } },
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_pd, .fmadd213, .dst0y, .src1y, .src2y, ._ },
                    } },
                }, .{
                    .required_features = .{ .fma, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .yword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .yword, .is = .qword } },
                        .{ .scalar_float = .{ .of = .yword, .is = .qword } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .to_mut_sse } },
                        .{ .src = .{ .mem, .to_sse, .to_mut_sse }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .to_mut_sse } },
                    },
                    .dst_temps = .{ .{ .ref = .src2 }, .unused },
                    .each = .{ .once = &.{
                        .{ ._, .v_pd, .fmadd231, .dst0y, .src0y, .src1y, ._ },
                    } },
                }, .{
                    .required_features = .{ .fma, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .to_mem } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .vector_4_f64, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
                        .{ .type = .vector_4_f64, .kind = .{ .mut_rc = .{ .ref = .src2, .rc = .sse } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
                        .{ .@"0:", .v_pd, .mova, .tmp1y, .memi(.src0y, .tmp0), ._, ._ },
                        .{ ._, .v_pd, .mova, .tmp2y, .memi(.src1y, .tmp0), ._, ._ },
                        .{ ._, .v_pd, .fmadd213, .tmp1y, .tmp2y, .memi(.src2y, .tmp0), ._ },
                        .{ ._, .v_pd, .mova, .memi(.dst0y, .tmp0), .tmp1y, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .to_mem } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fma" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, .v_sd, .mov, .tmp2x, .memi(.src1q, .tmp0), ._, ._ },
                        .{ ._, .v_sd, .mov, .tmp3x, .memi(.src2q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, .v_sd, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .to_mem } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fma" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._sd, .mov, .tmp2x, .memi(.src1q, .tmp0), ._, ._ },
                        .{ ._, ._sd, .mov, .tmp3x, .memi(.src2q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._sd, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .to_mem } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fma" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._ps, .xor, .tmp2x, .tmp2x, ._, ._ },
                        .{ ._, ._ps, .xor, .tmp3x, .tmp3x, ._, ._ },
                        .{ ._, ._ps, .movl, .tmp1x, .memi(.src0q, .tmp0), ._, ._ },
                        .{ ._, ._ps, .movl, .tmp2x, .memi(.src1q, .tmp0), ._, ._ },
                        .{ ._, ._ps, .movl, .tmp3x, .memi(.src2q, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._ps, .movl, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, .x87, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .to_mem } },
                    },
                    .call_frame = .{ .size = 16 * 3, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmax" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .reg = .st0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._ps, .mova, .tmp0x, .mem(.src0x), ._, ._ },
                        .{ ._, ._ps, .mova, .mem(.tmp1x), .tmp0x, ._, ._ },
                        .{ ._, ._ps, .mova, .tmp0x, .mem(.src1x), ._, ._ },
                        .{ ._, ._ps, .mova, .memd(.tmp1x, 16), .tmp0x, ._, ._ },
                        .{ ._, ._ps, .mova, .tmp0x, .mem(.src2x), ._, ._ },
                        .{ ._, ._ps, .mova, .memd(.tmp1x, 16 * 2), .tmp0x, ._, ._ },
                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .to_mem } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmax" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .mem(.src2), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, .x87, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .to_mem } },
                    },
                    .call_frame = .{ .size = 16 * 3, .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmax" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._ps, .mova, .mem(.tmp2x), .tmp1x, ._, ._ },
                        .{ ._, ._ps, .mova, .tmp1x, .memi(.src1x, .tmp0), ._, ._ },
                        .{ ._, ._ps, .mova, .memd(.tmp2x, 16), .tmp1x, ._, ._ },
                        .{ ._, ._ps, .mova, .tmp1x, .memi(.src2x, .tmp0), ._, ._ },
                        .{ ._, ._ps, .mova, .memd(.tmp2x, 16 * 2), .tmp1x, ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
                        .{ ._, .f_p, .st, .memi(.dst0t, .tmp0), ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .to_mem } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "__fmax" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.dst0, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .memi(.src1, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp4p, .memi(.src2, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                    },
                    .patterns = &.{
                        .{ .src = .{
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } },
                            .{ .to_param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } },
                        } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .extern_func = "fmaq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .to_mem } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmaq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                        .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .mem(.src2), ._, ._ },
                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .to_mem } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmaq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp2x, .memi(.src1x, .tmp0), ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp3x, .memi(.src2x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .to_mem } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmaq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp2x, .memi(.src1x, .tmp0), ._, ._ },
                        .{ ._, ._dqa, .mov, .tmp3x, .memi(.src2x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .sysv64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .to_mem } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmaq" } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ },
                        .{ ._, ._ps, .mova, .tmp2x, .memi(.src1x, .tmp0), ._, ._ },
                        .{ ._, ._ps, .mova, .tmp3x, .memi(.src2x, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .to_mem } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmaq" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memi(.src1, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .memi(.src2, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp5x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .to_mem } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmaq" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memi(.src1, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .memi(.src2, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp5x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_cc_abi = .win64,
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .to_mem } },
                    },
                    .call_frame = .{ .alignment = .@"16" },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                        .{ .type = .usize, .kind = .{ .extern_func = "fmaq" } },
                        .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .mem, .unused },
                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                        .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp2p, .memi(.src1, .tmp0), ._, ._ },
                        .{ ._, ._, .lea, .tmp3p, .memi(.src2, .tmp0), ._, ._ },
                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
                        .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp5x, ._, ._ },
                        .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
                        .{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f} {f} {f} {f}", .{
                        @tagName(air_tag),
                        cg.typeOf(bin_op.lhs).fmt(pt),
                        ops[0].tracking(cg),
                        ops[1].tracking(cg),
                        ops[2].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs, pl_op.operand }, &ops, cg);
            },
            .field_parent_ptr => {
                const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
                const field_parent_ptr = cg.air.extraData(Air.FieldParentPtr, ty_pl.payload).data;
                var ops = try cg.tempsFromOperands(inst, .{field_parent_ptr.field_ptr});
                try ops[0].toOffset(-@as(i32, @intCast(codegen.fieldOffset(
                    ty_pl.ty.toType(),
                    cg.typeOf(field_parent_ptr.field_ptr),
                    field_parent_ptr.field_index,
                    zcu,
                ))), cg);
                try ops[0].finish(inst, &.{field_parent_ptr.field_ptr}, &ops, cg);
            },
            .wasm_memory_size, .wasm_memory_grow => unreachable,
            .cmp_lt_errors_len => |air_tag| {
                const un_op = air_datas[@intFromEnum(inst)].un_op;
                var ops = try cg.tempsFromOperands(inst, .{un_op});
                var res: [1]Temp = undefined;
                cg.select(&res, &.{.bool}, &ops, comptime &.{ .{
                    .src_constraints = .{ .{ .int = .byte }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .anyerror, .kind = .{ .lazy_sym = .{ .kind = .const_data } } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .cc = .be }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp1p, .lea(.tmp0), ._, ._ },
                        .{ ._, ._, .cmp, .src0b, .lea(.tmp1b), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .int = .word }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .anyerror, .kind = .{ .lazy_sym = .{ .kind = .const_data } } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .cc = .be }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp1p, .lea(.tmp0), ._, ._ },
                        .{ ._, ._, .cmp, .src0w, .lea(.tmp1w), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .int = .dword }, .any, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .none, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .anyerror, .kind = .{ .lazy_sym = .{ .kind = .const_data } } },
                        .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .cc = .be }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .lea, .tmp1p, .lea(.tmp0), ._, ._ },
                        .{ ._, ._, .cmp, .src0d, .lea(.tmp1d), ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => return cg.fail("failed to select {s} {f}", .{
                        @tagName(air_tag),
                        ops[0].tracking(cg),
                    }),
                    else => |e| return e,
                };
                try res[0].finish(inst, &.{un_op}, &ops, cg);
            },
            .err_return_trace => {
                const ert: Temp = .{ .index = err_ret_trace_index };
                try ert.finish(inst, &.{}, &.{}, cg);
            },
            .set_err_return_trace => {
                const un_op = air_datas[@intFromEnum(inst)].un_op;
                var ops = try cg.tempsFromOperands(inst, .{un_op});
                switch (ops[0].unwrap(cg)) {
                    .ref => {
                        const result = try cg.allocRegOrMem(err_ret_trace_index, true);
                        try cg.genCopy(.usize, result, ops[0].tracking(cg).short, .{});
                        tracking_log.debug("{f} => {f} (birth)", .{ err_ret_trace_index, result });
                        cg.inst_tracking.putAssumeCapacityNoClobber(err_ret_trace_index, .init(result));
                    },
                    .temp => |temp_index| {
                        const temp_tracking = temp_index.tracking(cg);
                        tracking_log.debug("{f} => {f} (birth)", .{ err_ret_trace_index, temp_tracking.short });
                        cg.inst_tracking.putAssumeCapacityNoClobber(err_ret_trace_index, temp_tracking.*);
                        assert(cg.reuseTemp(err_ret_trace_index, temp_index.toIndex(), temp_tracking));
                    },
                    .err_ret_trace => unreachable,
                }
            },
            .addrspace_cast => {
                const ty_op = air_datas[@intFromEnum(inst)].ty_op;
                const ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
                try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg);
            },
            .save_err_return_trace_index => {
                const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
                const agg_ty = ty_pl.ty.toType();
                assert(agg_ty.containerLayout(zcu) != .@"packed");
                var ert: Temp = .{ .index = err_ret_trace_index };
                var res = try ert.load(.usize, .{ .disp = @intCast(agg_ty.structFieldOffset(ty_pl.payload, zcu)) }, cg);
                try ert.die(cg);
                try res.finish(inst, &.{}, &.{}, cg);
            },
            .runtime_nav_ptr => {
                const ty_nav = air_datas[@intFromEnum(inst)].ty_nav;
                const nav = ip.getNav(ty_nav.nav);
                const is_threadlocal = zcu.comp.config.any_non_single_threaded and nav.isThreadlocal(ip);
                if (is_threadlocal) if (cg.target.ofmt == .coff or cg.mod.pic) {
                    try cg.spillRegisters(&.{ .rdi, .rax });
                } else {
                    try cg.spillRegisters(&.{.rax});
                };
                var res = try cg.tempInit(.fromInterned(ty_nav.ty), .{ .lea_nav = ty_nav.nav });
                if (is_threadlocal) while (try res.toRegClass(true, .general_purpose, cg)) {};
                try res.finish(inst, &.{}, &.{}, cg);
            },
            .c_va_arg => try cg.airVaArg(inst),
            .c_va_copy => try cg.airVaCopy(inst),
            .c_va_end => try cg.airVaEnd(inst),
            .c_va_start => try cg.airVaStart(inst),
            .legalize_vec_store_elem => {
                const pl_op = air_datas[@intFromEnum(inst)].pl_op;
                const bin = cg.air.extraData(Air.Bin, pl_op.payload).data;
                // vector_ptr, index, elem_val
                var ops = try cg.tempsFromOperands(inst, .{ pl_op.operand, bin.lhs, bin.rhs });
                cg.select(&.{}, &.{}, &ops, comptime &.{ .{
                    .src_constraints = .{ .{ .ptr_bool_vec = .byte }, .any, .bool },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .{ .imm = 0 } } },
                    },
                    .extra_temps = .{
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .lea(.src0b), ._, ._ },
                        .{ ._, ._r, .bt, .tmp0d, .src1d, ._, ._ },
                        .{ ._, ._, .mov, .lea(.src0b), .tmp0b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .ptr_bool_vec = .byte }, .any, .bool },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .{ .imm = 1 } } },
                    },
                    .extra_temps = .{
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .lea(.src0b), ._, ._ },
                        .{ ._, ._s, .bt, .tmp0d, .src1d, ._, ._ },
                        .{ ._, ._, .mov, .lea(.src0b), .tmp0b, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .ptr_bool_vec = .byte }, .any, .bool },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .to_gpr } },
                    },
                    .extra_temps = .{
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .lea(.src0b), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .bt, .tmp1d, .src1d, ._, ._ },
                        .{ ._, ._s, .bt, .tmp0d, .src1d, ._, ._ },
                        .{ ._, ._, .@"test", .src2b, .si(1), ._, ._ },
                        .{ ._, ._z, .cmov, .tmp0d, .tmp1d, ._, ._ },
                        .{ ._, ._, .mov, .lea(.src0b), .tmp0b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .ptr_bool_vec = .byte }, .any, .bool },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .to_gpr } },
                    },
                    .extra_temps = .{
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .lea(.src0b), ._, ._ },
                        .{ ._, ._, .@"test", .src2b, .si(1), ._, ._ },
                        .{ ._, ._nz, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._r, .bt, .tmp0d, .src1d, ._, ._ },
                        .{ ._, ._mp, .j, .@"1f", ._, ._, ._ },
                        .{ .@"0:", ._s, .bt, .tmp0d, .src1d, ._, ._ },
                        .{ .@"1:", ._, .mov, .lea(.src0b), .tmp0b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .ptr_bool_vec = .word }, .any, .bool },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .{ .imm = 0 } } },
                    },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._r, .bt, .lea(.src0w), .src1w, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .ptr_bool_vec = .word }, .any, .bool },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .{ .imm = 1 } } },
                    },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._s, .bt, .lea(.src0d), .src1d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .ptr_bool_vec = .word }, .any, .bool },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .to_gpr } },
                    },
                    .extra_temps = .{
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .movzx, .tmp0d, .lea(.src0w), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .bt, .tmp1d, .src1d, ._, ._ },
                        .{ ._, ._s, .bt, .tmp0d, .src1d, ._, ._ },
                        .{ ._, ._, .@"test", .src2b, .si(1), ._, ._ },
                        .{ ._, ._z, .cmov, .tmp0d, .tmp1d, ._, ._ },
                        .{ ._, ._, .mov, .lea(.src0w), .tmp0w, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .ptr_bool_vec = .word }, .any, .bool },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .to_gpr } },
                    },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .@"test", .src2b, .si(1), ._, ._ },
                        .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .bt, .lea(.src0w), .src1w, ._, ._ },
                        .{ ._, ._mp, .j, .@"0f", ._, ._, ._ },
                        .{ .@"1:", ._s, .bt, .lea(.src0w), .src1w, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .ptr_any_bool_vec, .any, .bool },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .{ .imm = 0 } } },
                    },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._r, .bt, .lea(.src0d), .src1d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .ptr_any_bool_vec, .any, .bool },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .{ .imm = 1 } } },
                    },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._s, .bt, .lea(.src0d), .src1d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .{ .ptr_bool_vec = .dword }, .any, .bool },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .to_gpr } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .lea(.src0d), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ },
                        .{ ._, ._r, .bt, .tmp1d, .src1d, ._, ._ },
                        .{ ._, ._s, .bt, .tmp0d, .src1d, ._, ._ },
                        .{ ._, ._, .@"test", .src2b, .si(1), ._, ._ },
                        .{ ._, ._z, .cmov, .tmp0d, .tmp1d, ._, ._ },
                        .{ ._, ._, .mov, .lea(.src0d), .tmp0d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", .cmov, null, null },
                    .src_constraints = .{ .{ .ptr_bool_vec = .qword }, .any, .bool },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .to_gpr } },
                    },
                    .extra_temps = .{
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0q, .lea(.src0q), ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ },
                        .{ ._, ._r, .bt, .tmp1q, .src1q, ._, ._ },
                        .{ ._, ._s, .bt, .tmp0q, .src1q, ._, ._ },
                        .{ ._, ._, .@"test", .src2b, .si(1), ._, ._ },
                        .{ ._, ._z, .cmov, .tmp0q, .tmp1q, ._, ._ },
                        .{ ._, ._, .mov, .lea(.src0q), .tmp0q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .cmov, null, null, null },
                    .src_constraints = .{ .ptr_any_bool_vec, .any, .bool },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .to_gpr } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0d, .src1d, ._, ._ },
                        .{ ._, ._r, .sh, .tmp0d, .ui(5), ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .leasi(.src0d, .@"4", .tmp0), ._, ._ },
                        .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ },
                        .{ ._, ._r, .bt, .tmp2d, .src1d, ._, ._ },
                        .{ ._, ._s, .bt, .tmp1d, .src1d, ._, ._ },
                        .{ ._, ._, .@"test", .src2b, .si(1), ._, ._ },
                        .{ ._, ._z, .cmov, .tmp1d, .tmp2d, ._, ._ },
                        .{ ._, ._, .mov, .leasi(.src0d, .@"4", .tmp0), .tmp1d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .ptr_any_bool_vec, .any, .bool },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .to_gpr } },
                    },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .@"test", .src2b, .si(1), ._, ._ },
                        .{ ._, ._nz, .j, .@"1f", ._, ._, ._ },
                        .{ ._, ._r, .bt, .lea(.src0d), .src1d, ._, ._ },
                        .{ ._, ._mp, .j, .@"0f", ._, ._, ._ },
                        .{ .@"1:", ._s, .bt, .lea(.src0d), .src1d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .any, .any, .{ .int = .byte } },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .simm32, .imm8 } },
                        .{ .src = .{ .to_gpr, .simm32, .to_gpr } },
                    },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .leaa(.src0b, .add_src0_elem_size_mul_src1), .src2b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .any, .any, .{ .int = .byte } },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .imm8 } },
                        .{ .src = .{ .to_gpr, .to_gpr, .to_gpr } },
                    },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .leai(.src0b, .src1), .src2b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .any, .any, .{ .int = .word } },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .simm32, .imm16 } },
                        .{ .src = .{ .to_gpr, .simm32, .to_gpr } },
                    },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .leaa(.src0w, .add_src0_elem_size_mul_src1), .src2w, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .any, .any, .{ .int = .word } },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .imm16 } },
                        .{ .src = .{ .to_gpr, .to_gpr, .to_gpr } },
                    },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .leasi(.src0w, .@"2", .src1), .src2w, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .any, .any, .{ .float = .word } },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .simm32, .to_sse } },
                    },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .extr, .leaa(.src0w, .add_src0_elem_size_mul_src1), .src2x, .ui(0), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .any, .any, .{ .float = .word } },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .simm32, .to_sse } },
                    },
                    .each = .{ .once = &.{
                        .{ ._, .p_w, .extr, .leaa(.src0w, .add_src0_elem_size_mul_src1), .src2x, .ui(0), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .any, .any, .{ .float = .word } },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .simm32, .to_sse } },
                    },
                    .extra_temps = .{
                        .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .each = .{ .once = &.{
                        .{ ._, .p_w, .extr, .tmp0d, .src2x, .ui(0), ._ },
                        .{ ._, ._, .mov, .leaa(.src0w, .add_src0_elem_size_mul_src1), .tmp0w, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .any, .any, .{ .float = .word } },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .simm32, .to_sse } },
                    },
                    .extra_temps = .{
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .each = .{ .once = &.{
                        .{ ._, ._ss, .mov, .mem(.tmp1d), .src2x, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .mem(.tmp1d), ._, ._ },
                        .{ ._, ._, .mov, .leaa(.src0w, .add_src0_elem_size_mul_src1), .tmp1w, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .any, .any, .{ .float = .word } },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .to_sse } },
                    },
                    .each = .{ .once = &.{
                        .{ ._, .vp_w, .extr, .leasi(.src0w, .@"2", .src1), .src2x, .ui(0), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .any, .any, .{ .float = .word } },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .to_sse } },
                    },
                    .each = .{ .once = &.{
                        .{ ._, .p_w, .extr, .leasi(.src0w, .@"2", .src1), .src2x, .ui(0), ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .any, .any, .{ .float = .word } },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .simm32, .to_sse } },
                    },
                    .extra_temps = .{
                        .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .each = .{ .once = &.{
                        .{ ._, .p_w, .extr, .tmp0d, .src2x, .ui(0), ._ },
                        .{ ._, ._, .mov, .leasi(.src0w, .@"2", .src1), .tmp0w, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .any, .any, .{ .float = .word } },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .simm32, .to_sse } },
                    },
                    .extra_temps = .{
                        .{ .type = .f32, .kind = .mem },
                        .{ .type = .f16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .each = .{ .once = &.{
                        .{ ._, ._ss, .mov, .mem(.tmp1d), .src2x, ._, ._ },
                        .{ ._, ._, .mov, .tmp1d, .mem(.tmp1d), ._, ._ },
                        .{ ._, ._, .mov, .leasi(.src0w, .@"2", .src1), .tmp1w, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .any, .any, .{ .int = .dword } },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .simm32, .imm32 } },
                        .{ .src = .{ .to_gpr, .simm32, .to_gpr } },
                    },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .leaa(.src0d, .add_src0_elem_size_mul_src1), .src2d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .any, .any, .{ .int = .dword } },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .imm32 } },
                        .{ .src = .{ .to_gpr, .to_gpr, .to_gpr } },
                    },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .leasi(.src0d, .@"4", .src1), .src2d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .any, .any, .{ .float = .dword } },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .simm32, .to_sse } },
                    },
                    .each = .{ .once = &.{
                        .{ ._, .v_ss, .mov, .leaa(.src0d, .add_src0_elem_size_mul_src1), .src2x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .any, .any, .{ .float = .dword } },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .simm32, .to_sse } },
                    },
                    .each = .{ .once = &.{
                        .{ ._, ._ss, .mov, .leaa(.src0d, .add_src0_elem_size_mul_src1), .src2x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .any, .any, .{ .float = .dword } },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .to_sse } },
                    },
                    .each = .{ .once = &.{
                        .{ ._, .v_ss, .mov, .leasi(.src0d, .@"4", .src1), .src2x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .any, .any, .{ .float = .dword } },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .to_sse } },
                    },
                    .each = .{ .once = &.{
                        .{ ._, ._ss, .mov, .leasi(.src0d, .@"4", .src1), .src2x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .any, .any, .{ .int = .qword } },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .simm32, .simm32 } },
                        .{ .src = .{ .to_gpr, .simm32, .to_gpr } },
                    },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .leaa(.src0q, .add_src0_elem_size_mul_src1), .src2q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .any, .any, .{ .int = .qword } },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .simm32 } },
                        .{ .src = .{ .to_gpr, .to_gpr, .to_gpr } },
                    },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .leasi(.src0q, .@"8", .src1), .src2q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .any, .any, .{ .float = .qword } },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .simm32, .to_sse } },
                    },
                    .each = .{ .once = &.{
                        .{ ._, .v_sd, .mov, .leaa(.src0q, .add_src0_elem_size_mul_src1), .src2x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .any, .any, .{ .float = .qword } },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .simm32, .to_sse } },
                    },
                    .each = .{ .once = &.{
                        .{ ._, ._sd, .mov, .leaa(.src0q, .add_src0_elem_size_mul_src1), .src2x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .any, .any, .{ .float = .qword } },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .simm32, .to_sse } },
                    },
                    .each = .{ .once = &.{
                        .{ ._, ._ps, .movl, .leaa(.src0q, .add_src0_elem_size_mul_src1), .src2x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .any, .any, .{ .float = .qword } },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .to_sse } },
                    },
                    .each = .{ .once = &.{
                        .{ ._, .v_sd, .mov, .leasi(.src0q, .@"8", .src1), .src2x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .any, .any, .{ .float = .qword } },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .to_sse } },
                    },
                    .each = .{ .once = &.{
                        .{ ._, ._sd, .mov, .leasi(.src0q, .@"8", .src1), .src2x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, null, null, null },
                    .src_constraints = .{ .any, .any, .{ .float = .qword } },
                    .patterns = &.{
                        .{ .src = .{ .to_gpr, .to_gpr, .to_sse } },
                    },
                    .each = .{ .once = &.{
                        .{ ._, ._ps, .movl, .leasi(.src0q, .@"8", .src1), .src2x, ._, ._ },
                    } },
                } }) catch |err| switch (err) {
                    error.SelectFailed => {
                        const elem_size = cg.typeOf(bin.rhs).abiSize(zcu);
                        while (try ops[0].toRegClass(true, .general_purpose, cg) or
                            try ops[1].toRegClass(true, .general_purpose, cg))
                        {}
                        const base_reg = ops[0].tracking(cg).short.register.to64();
                        const rhs_reg = ops[1].tracking(cg).short.register.to64();
                        if (!std.math.isPowerOfTwo(elem_size)) {
                            try cg.spillEflagsIfOccupied();
                            try cg.asmRegisterRegisterImmediate(
                                .{ .i_, .mul },
                                rhs_reg,
                                rhs_reg,
                                .u(elem_size),
                            );
                            try cg.asmRegisterMemory(.{ ._, .lea }, base_reg, .{
                                .base = .{ .reg = base_reg },
                                .mod = .{ .rm = .{ .index = rhs_reg } },
                            });
                        } else if (elem_size > 8) {
                            try cg.spillEflagsIfOccupied();
                            try cg.asmRegisterImmediate(
                                .{ ._l, .sh },
                                rhs_reg,
                                .u(std.math.log2_int(u64, elem_size)),
                            );
                            try cg.asmRegisterMemory(.{ ._, .lea }, base_reg, .{
                                .base = .{ .reg = base_reg },
                                .mod = .{ .rm = .{ .index = rhs_reg } },
                            });
                        } else try cg.asmRegisterMemory(.{ ._, .lea }, base_reg, .{
                            .base = .{ .reg = base_reg },
                            .mod = .{ .rm = .{
                                .index = rhs_reg,
                                .scale = .fromFactor(@intCast(elem_size)),
                            } },
                        });
                        try ops[0].store(&ops[2], .{}, cg);
                    },
                    else => |e| return e,
                };
                for (ops) |op| try op.die(cg);
            },

            // No soft-float `Legalize` features are enabled, so this instruction never appears.
            .legalize_compiler_rt_call => unreachable,

            .work_item_id, .work_group_size, .work_group_id => unreachable,
        }
        try cg.resetTemps(@enumFromInt(0));
        cg.checkInvariantsAfterAirInst();
    }
    verbose_tracking_log.debug("{f}", .{cg.fmtTracking()});
}

fn genLazy(cg: *CodeGen, lazy_sym: link.File.LazySymbol) InnerError!void {
    const pt = cg.pt;
    const zcu = pt.zcu;
    const ip = &zcu.intern_pool;
    switch (ip.indexToKey(lazy_sym.ty)) {
        .enum_type => {
            const enum_ty: Type = .fromInterned(lazy_sym.ty);
            wip_mir_log.debug("{f}.@tagName:", .{enum_ty.fmt(pt)});

            const ret_regs = abi.getCAbiIntReturnRegs(.auto)[0..2].*;
            const ret_locks = cg.register_manager.lockRegsAssumeUnused(2, ret_regs);
            defer for (ret_locks) |lock| cg.register_manager.unlockReg(lock);

            const param_reg = abi.getCAbiIntParamRegs(.auto)[0];
            const param_lock = cg.register_manager.lockReg(param_reg);
            defer if (param_lock) |lock| cg.register_manager.unlockReg(lock);

            const ret_mcv: MCValue = .{ .register_pair = ret_regs };

            const data_reg = try cg.register_manager.allocReg(null, abi.RegisterClass.gp);
            const data_lock = cg.register_manager.lockRegAssumeUnused(data_reg);
            defer cg.register_manager.unlockReg(data_lock);
            try cg.asmRegisterMemory(.{ ._, .lea }, data_reg.to64(), .{
                .base = .{ .lazy_sym = .{ .kind = .const_data, .ty = lazy_sym.ty } },
            });

            var data_off: i32 = 0;
            const reset_index = cg.next_temp_index;
            const tag_names = ip.loadEnumType(lazy_sym.ty).names;
            for (0..tag_names.len) |tag_index| {
                var enum_temp = try cg.tempInit(enum_ty, if (enum_ty.abiSize(zcu) <= @as(u4, switch (cg.target.cpu.arch) {
                    else => unreachable,
                    .x86 => 4,
                    .x86_64 => 8,
                })) .{ .register = param_reg } else .{ .indirect = .{ .reg = param_reg } });

                const tag_name_len = tag_names.get(ip)[tag_index].length(ip);
                var tag_temp = try cg.tempFromValue(try pt.enumValueFieldIndex(enum_ty, @intCast(tag_index)));
                const cc_temp = enum_temp.cmpInts(.neq, &tag_temp, cg) catch |err| switch (err) {
                    error.SelectFailed => unreachable,
                    else => |e| return e,
                };
                try enum_temp.die(cg);
                try tag_temp.die(cg);
                const skip_reloc = try cg.asmJccReloc(cc_temp.tracking(cg).short.eflags, undefined);
                try cc_temp.die(cg);

                try cg.genSetReg(
                    ret_mcv.register_pair[0],
                    .usize,
                    .{ .register_offset = .{ .reg = data_reg, .off = data_off } },
                    .{},
                );
                try cg.genSetReg(ret_mcv.register_pair[1], .usize, .{ .immediate = tag_name_len }, .{});
                try cg.asmOpOnly(.{ ._, .ret });

                cg.performReloc(skip_reloc);

                data_off += @intCast(tag_name_len + 1);

                try cg.resetTemps(reset_index);
            }

            try cg.genSetReg(ret_mcv.register_pair[0], .usize, .{ .immediate = 0 }, .{});
            try cg.asmOpOnly(.{ ._, .ret });
        },
        .error_set_type => |error_set_type| {
            const err_ty: Type = .fromInterned(lazy_sym.ty);
            wip_mir_log.debug("{f}.@errorCast:", .{err_ty.fmt(pt)});

            const ret_reg = abi.getCAbiIntReturnRegs(.auto)[0];
            const ret_lock = cg.register_manager.lockRegAssumeUnused(ret_reg);
            defer cg.register_manager.unlockReg(ret_lock);

            const param_reg = abi.getCAbiIntParamRegs(.auto)[0];
            const param_lock = cg.register_manager.lockReg(param_reg);
            defer if (param_lock) |lock| cg.register_manager.unlockReg(lock);

            const ret_mcv: MCValue = .{ .register = ret_reg };
            const err_mcv: MCValue = .{ .register = param_reg };
            var err_temp = try cg.tempInit(err_ty, err_mcv);

            const ExpectedContents = [32]Mir.Inst.Index;
            var stack align(@max(@alignOf(ExpectedContents), @alignOf(std.heap.StackFallbackAllocator(0)))) =
                std.heap.stackFallback(@sizeOf(ExpectedContents), cg.gpa);
            const allocator = stack.get();

            const relocs = try allocator.alloc(Mir.Inst.Index, error_set_type.names.len);
            defer allocator.free(relocs);

            const reset_index = cg.next_temp_index;
            for (0.., relocs) |tag_index, *reloc| {
                var tag_temp = try cg.tempInit(.anyerror, .{
                    .immediate = ip.getErrorValueIfExists(error_set_type.names.get(ip)[tag_index]).?,
                });
                const cc_temp = err_temp.cmpInts(.eq, &tag_temp, cg) catch |err| switch (err) {
                    error.SelectFailed => unreachable,
                    else => |e| return e,
                };
                try tag_temp.die(cg);
                reloc.* = try cg.asmJccReloc(cc_temp.tracking(cg).short.eflags, undefined);
                try cc_temp.die(cg);
                try cg.resetTemps(reset_index);
            }
            try err_temp.die(cg);

            try cg.genCopy(.usize, ret_mcv, .{ .immediate = 0 }, .{});
            for (relocs) |reloc| cg.performReloc(reloc);
            assert(ret_mcv.register == err_mcv.register);
            try cg.asmOpOnly(.{ ._, .ret });
        },
        else => return cg.fail(
            "TODO implement {s} for {f}",
            .{ @tagName(lazy_sym.kind), Type.fromInterned(lazy_sym.ty).fmt(pt) },
        ),
    }
    try cg.resetTemps(@enumFromInt(0));
    cg.checkInvariantsAfterAirInst();
}

fn getValue(self: *CodeGen, value: MCValue, inst: ?Air.Inst.Index) !void {
    for (value.getRegs()) |reg| try self.register_manager.getReg(reg, inst);
    switch (value) {
        else => {},
        .eflags, .register_overflow => self.eflags_inst = inst,
    }
}

fn getValueIfFree(self: *CodeGen, value: MCValue, inst: ?Air.Inst.Index) void {
    for (value.getRegs()) |reg| if (self.register_manager.isRegFree(reg))
        self.register_manager.getRegAssumeFree(reg, inst);
}

const FreeOptions = struct { emit_instructions: bool = true };

fn freeReg(self: *CodeGen, reg: Register, comptime opts: FreeOptions) !void {
    self.register_manager.freeReg(reg);
    if (opts.emit_instructions and reg.isClass(.x87)) try self.asmRegister(.{ .f_, .free }, reg);
}

fn freeValue(self: *CodeGen, value: MCValue, comptime opts: FreeOptions) !void {
    switch (value) {
        .register => |reg| try self.freeReg(reg, opts),
        inline .register_pair,
        .register_triple,
        .register_quadruple,
        => |regs| for (regs) |reg| try self.freeReg(reg, opts),
        .register_offset, .indirect => |reg_off| try self.freeReg(reg_off.reg, opts),
        .register_overflow => |reg_ov| {
            try self.freeReg(reg_ov.reg, opts);
            self.eflags_inst = null;
        },
        .register_mask => |reg_mask| try self.freeReg(reg_mask.reg, opts),
        .eflags => self.eflags_inst = null,
        else => {}, // TODO process stack allocation death
    }
}

fn feed(self: *CodeGen, bt: *Air.Liveness.BigTomb, operand: Air.Inst.Ref) !void {
    if (bt.feed()) if (operand.toIndex()) |inst| try self.processDeath(inst, .{});
}

/// Asserts there is already capacity to insert into top branch inst_table.
fn processDeath(self: *CodeGen, inst: Air.Inst.Index, comptime opts: FreeOptions) !void {
    try self.inst_tracking.getPtr(inst).?.die(self, inst, opts);
}

fn finishAirResult(self: *CodeGen, inst: Air.Inst.Index, result: MCValue) void {
    if (self.liveness.isUnused(inst) and self.air.instructions.items(.tag)[@intFromEnum(inst)] != .arg) switch (result) {
        .none, .dead, .unreach => {},
        else => unreachable, // Why didn't the result die?
    } else {
        tracking_log.debug("{f} => {f} (birth)", .{ inst, result });
        self.inst_tracking.putAssumeCapacityNoClobber(inst, .init(result));
        // In some cases, an operand may be reused as the result.
        // If that operand died and was a register, it was freed by
        // processDeath, so we have to "re-allocate" the register.
        self.getValueIfFree(result, inst);
    }
}

fn finishAir(
    self: *CodeGen,
    inst: Air.Inst.Index,
    result: MCValue,
    operands: [Air.Liveness.bpi - 1]Air.Inst.Ref,
) !void {
    const tomb_bits = self.liveness.getTombBits(inst);
    for (0.., operands) |op_index, op| {
        if (tomb_bits & @as(Air.Liveness.Bpi, 1) << @intCast(op_index) == 0) continue;
        if (self.reused_operands.isSet(op_index)) continue;
        try self.processDeath(op.toIndexAllowNone() orelse continue, .{});
    }
    self.finishAirResult(inst, result);
}

const FrameLayout = struct {
    stack_mask: u32,
    stack_adjust: u32,
    save_reg_list: Mir.RegisterList,
};

fn setFrameLoc(
    self: *CodeGen,
    frame_index: FrameIndex,
    base: Register,
    offset: *i32,
    comptime aligned: bool,
) void {
    const frame_i = @intFromEnum(frame_index);
    if (aligned) {
        const alignment = self.frame_allocs.items(.abi_align)[frame_i];
        offset.* = @intCast(alignment.forward(@intCast(offset.*)));
    }
    self.frame_locs.set(frame_i, .{ .base = base, .disp = offset.* });
    offset.* += self.frame_allocs.items(.abi_size)[frame_i];
}

fn computeFrameLayout(self: *CodeGen, cc: std.builtin.CallingConvention.Tag) !FrameLayout {
    const frame_allocs_len = self.frame_allocs.len;
    try self.frame_locs.resize(self.gpa, frame_allocs_len);
    const stack_frame_order = try self.gpa.alloc(FrameIndex, frame_allocs_len - FrameIndex.named_count);
    defer self.gpa.free(stack_frame_order);

    const frame_size = self.frame_allocs.items(.abi_size);
    const frame_align = self.frame_allocs.items(.abi_align);
    const frame_offset = self.frame_locs.items(.disp);

    for (stack_frame_order, FrameIndex.named_count..) |*frame_order, frame_index|
        frame_order.* = @enumFromInt(frame_index);
    {
        const SortContext = struct {
            frame_align: @TypeOf(frame_align),
            pub fn lessThan(context: @This(), lhs: FrameIndex, rhs: FrameIndex) bool {
                return context.frame_align[@intFromEnum(lhs)].compare(.gt, context.frame_align[@intFromEnum(rhs)]);
            }
        };
        const sort_context = SortContext{ .frame_align = frame_align };
        std.mem.sort(FrameIndex, stack_frame_order, sort_context, SortContext.lessThan);
    }

    const call_frame_align = frame_align[@intFromEnum(FrameIndex.call_frame)];
    const stack_frame_align = frame_align[@intFromEnum(FrameIndex.stack_frame)];
    const args_frame_align = frame_align[@intFromEnum(FrameIndex.args_frame)];
    const needed_align = call_frame_align.max(stack_frame_align);
    const need_align_stack = needed_align.compare(.gt, args_frame_align);

    // Create list of registers to save in the prologue.
    // TODO handle register classes
    var save_reg_list: Mir.RegisterList = .empty;
    const callee_preserved_regs = abi.getCalleePreservedRegs(cc);
    for (callee_preserved_regs) |reg| {
        if (self.register_manager.isRegAllocated(reg)) {
            save_reg_list.push(callee_preserved_regs, reg);
        }
    }

    var rbp_offset: i32 = 0;
    self.setFrameLoc(.base_ptr, .rbp, &rbp_offset, false);
    self.setFrameLoc(.ret_addr, .rbp, &rbp_offset, false);
    self.setFrameLoc(.args_frame, .rbp, &rbp_offset, false);
    const stack_frame_align_offset = if (need_align_stack)
        0
    else
        save_reg_list.size(self.target) + frame_offset[@intFromEnum(FrameIndex.args_frame)];

    var rsp_offset: i32 = 0;
    self.setFrameLoc(.call_frame, .rsp, &rsp_offset, true);
    self.setFrameLoc(.stack_frame, .rsp, &rsp_offset, true);
    for (stack_frame_order) |frame_index| self.setFrameLoc(frame_index, .rsp, &rsp_offset, true);
    rsp_offset += stack_frame_align_offset;
    rsp_offset = @intCast(needed_align.forward(@intCast(rsp_offset)));
    rsp_offset -= stack_frame_align_offset;
    frame_size[@intFromEnum(FrameIndex.call_frame)] =
        @intCast(rsp_offset - frame_offset[@intFromEnum(FrameIndex.stack_frame)]);

    return .{
        .stack_mask = @as(u32, std.math.maxInt(u32)) << @intCast(if (need_align_stack) @intFromEnum(needed_align) else 0),
        .stack_adjust = @intCast(rsp_offset - frame_offset[@intFromEnum(FrameIndex.call_frame)]),
        .save_reg_list = save_reg_list,
    };
}

fn getFrameAddrAlignment(self: *CodeGen, frame_addr: bits.FrameAddr) InternPool.Alignment {
    const alloc_align = self.frame_allocs.get(@intFromEnum(frame_addr.index)).abi_align;
    return @enumFromInt(@min(@intFromEnum(alloc_align), @ctz(frame_addr.off)));
}

fn getFrameAddrSize(self: *CodeGen, frame_addr: bits.FrameAddr) u32 {
    return self.frame_allocs.get(@intFromEnum(frame_addr.index)).abi_size - @as(u31, @intCast(frame_addr.off));
}

fn allocFrameIndex(self: *CodeGen, alloc: FrameAlloc) !FrameIndex {
    const frame_allocs_slice = self.frame_allocs.slice();
    const frame_size = frame_allocs_slice.items(.abi_size);
    const frame_align = frame_allocs_slice.items(.abi_align);

    const stack_frame_align = &frame_align[@intFromEnum(FrameIndex.stack_frame)];
    stack_frame_align.* = stack_frame_align.max(alloc.abi_align);

    for (self.free_frame_indices.keys(), 0..) |frame_index, free_i| {
        const abi_size = frame_size[@intFromEnum(frame_index)];
        if (abi_size != alloc.abi_size) continue;
        const abi_align = &frame_align[@intFromEnum(frame_index)];
        abi_align.* = abi_align.max(alloc.abi_align);

        _ = self.free_frame_indices.swapRemoveAt(free_i);
        return frame_index;
    }
    const frame_index: FrameIndex = @enumFromInt(self.frame_allocs.len);
    try self.frame_allocs.append(self.gpa, alloc);
    return frame_index;
}

/// Use a pointer instruction as the basis for allocating stack memory.
fn allocMemPtr(self: *CodeGen, inst: Air.Inst.Index) !FrameIndex {
    const pt = self.pt;
    const zcu = pt.zcu;
    const ptr_ty = self.typeOfIndex(inst);
    const val_ty = ptr_ty.childType(zcu);
    return self.allocFrameIndex(.init(.{
        .size = std.math.cast(u32, val_ty.abiSize(zcu)) orelse {
            return self.fail("type '{f}' too big to fit into stack frame", .{val_ty.fmt(pt)});
        },
        .alignment = ptr_ty.ptrAlignment(zcu).max(.@"1"),
    }));
}

fn allocRegOrMem(self: *CodeGen, inst: Air.Inst.Index, reg_ok: bool) !MCValue {
    return self.allocRegOrMemAdvanced(self.typeOfIndex(inst), inst, reg_ok);
}

fn allocTempRegOrMem(self: *CodeGen, elem_ty: Type, reg_ok: bool) !MCValue {
    return self.allocRegOrMemAdvanced(elem_ty, null, reg_ok);
}

fn allocRegOrMemAdvanced(self: *CodeGen, ty: Type, inst: ?Air.Inst.Index, reg_ok: bool) !MCValue {
    const pt = self.pt;
    const zcu = pt.zcu;
    const abi_size = std.math.cast(u32, ty.abiSize(zcu)) orelse {
        return self.fail("type '{f}' too big to fit into stack frame", .{ty.fmt(pt)});
    };

    if (reg_ok) need_mem: {
        if (std.math.isPowerOfTwo(abi_size) and abi_size <= @as(u32, max_abi_size: switch (ty.zigTypeTag(zcu)) {
            .float => switch (ty.floatBits(self.target)) {
                16, 32, 64, 128 => 16,
                80 => break :need_mem,
                else => unreachable,
            },
            .vector => {
                const elem_ty = ty.childType(zcu);
                break :max_abi_size if (elem_ty.toIntern() == .bool_type)
                    8
                else if (self.floatBits(elem_ty)) |float_bits| switch (float_bits) {
                    16, 32, 64, 128 => self.vectorSize(.float),
                    80 => break :need_mem,
                    else => unreachable,
                } else self.vectorSize(.int);
            },
            else => 8,
        })) {
            if (self.register_manager.tryAllocReg(inst, self.regSetForType(ty))) |reg| {
                return MCValue{ .register = registerAlias(reg, abi_size) };
            }
        }
    }

    const frame_index = try self.allocFrameIndex(.initSpill(ty, zcu));
    return .{ .load_frame = .{ .index = frame_index } };
}

fn regClassForType(self: *CodeGen, ty: Type) Register.Class {
    const pt = self.pt;
    const zcu = pt.zcu;
    if (self.floatBits(ty)) |float_bits| return switch (float_bits) {
        80 => .x87,
        else => .sse,
    };
    if (!ty.isVector(zcu)) return .general_purpose;
    const elem_ty = ty.childType(zcu);
    return if (elem_ty.toIntern() == .bool_type)
        .general_purpose
    else if (self.floatBits(elem_ty)) |float_bits|
        if (float_bits == 80) .x87 else .sse
    else if (self.intInfo(elem_ty)) |_|
        .sse
    else
        .general_purpose;
}

fn regSetForRegClass(rc: Register.Class) RegisterManager.RegisterBitSet {
    return switch (rc) {
        .general_purpose => abi.RegisterClass.gp,
        .gphi => abi.RegisterClass.gphi,
        .segment, .ip, .cr, .dr => unreachable,
        .x87 => abi.RegisterClass.x87,
        .mmx => @panic("TODO"),
        .sse => abi.RegisterClass.sse,
    };
}

fn regSetForType(self: *CodeGen, ty: Type) RegisterManager.RegisterBitSet {
    return regSetForRegClass(self.regClassForType(ty));
}

fn vectorSize(cg: *CodeGen, kind: enum { int, float }) u6 {
    return if (cg.hasFeature(switch (kind) {
        .int => .avx2,
        .float => .avx,
    })) 32 else if (cg.hasFeature(.sse)) 16 else 8;
}

const State = struct {
    registers: RegisterManager.TrackedRegisters,
    reg_tracking: [RegisterManager.RegisterBitSet.bit_length]InstTracking,
    free_registers: RegisterManager.RegisterBitSet,
    next_temp_index: Temp.Index,
    inst_tracking_len: u32,
    scope_generation: u32,
};

fn initRetroactiveState(self: *CodeGen) State {
    const scope_generation = self.scope_generation + 1;
    self.scope_generation = scope_generation;

    var state: State = undefined;
    state.next_temp_index = @enumFromInt(0);
    state.inst_tracking_len = @intCast(self.inst_tracking.count());
    state.scope_generation = scope_generation;
    return state;
}

fn saveRetroactiveState(self: *CodeGen, state: *State) !void {
    try self.spillEflagsIfOccupied();
    const free_registers = self.register_manager.free_registers;
    var it = free_registers.iterator(.{ .kind = .unset });
    while (it.next()) |index| {
        const tracked_inst = self.register_manager.registers[index];
        state.registers[index] = tracked_inst;
        state.reg_tracking[index] = self.inst_tracking.get(tracked_inst).?;
    }
    state.free_registers = free_registers;
}

fn saveState(self: *CodeGen) !State {
    var state = self.initRetroactiveState();
    try self.saveRetroactiveState(&state);
    return state;
}

fn restoreState(self: *CodeGen, state: State, deaths: []const Air.Inst.Index, comptime opts: struct {
    emit_instructions: bool,
    update_tracking: bool,
    resurrect: bool,
    close_scope: bool,
}) !void {
    if (opts.close_scope) {
        for (
            self.inst_tracking.keys()[@intFromEnum(state.next_temp_index)..@intFromEnum(self.next_temp_index)],
            self.inst_tracking.values()[@intFromEnum(state.next_temp_index)..@intFromEnum(self.next_temp_index)],
        ) |inst, *tracking| try tracking.die(self, inst, .{ .emit_instructions = opts.emit_instructions });
        self.next_temp_index = state.next_temp_index;
        for (
            self.inst_tracking.keys()[state.inst_tracking_len..],
            self.inst_tracking.values()[state.inst_tracking_len..],
        ) |inst, *tracking| try tracking.die(self, inst, .{ .emit_instructions = opts.emit_instructions });
        self.inst_tracking.shrinkRetainingCapacity(state.inst_tracking_len);
    }

    if (opts.resurrect) {
        for (
            self.inst_tracking.keys()[0..@intFromEnum(state.next_temp_index)],
            self.inst_tracking.values()[0..@intFromEnum(state.next_temp_index)],
        ) |inst, *tracking| try tracking.resurrect(self, inst, state.scope_generation);
        for (
            self.inst_tracking.keys()[Temp.Index.max..state.inst_tracking_len],
            self.inst_tracking.values()[Temp.Index.max..state.inst_tracking_len],
        ) |inst, *tracking| try tracking.resurrect(self, inst, state.scope_generation);
    }
    for (deaths) |death| try self.processDeath(death, .{ .emit_instructions = opts.emit_instructions });

    const ExpectedContents = [@typeInfo(RegisterManager.TrackedRegisters).array.len]RegisterLock;
    var stack align(@max(@alignOf(ExpectedContents), @alignOf(std.heap.StackFallbackAllocator(0)))) =
        if (opts.update_tracking) {} else std.heap.stackFallback(@sizeOf(ExpectedContents), self.gpa);

    var reg_locks = if (opts.update_tracking) {} else try std.array_list.Managed(RegisterLock).initCapacity(
        stack.get(),
        @typeInfo(ExpectedContents).array.len,
    );
    defer if (!opts.update_tracking) {
        for (reg_locks.items) |lock| self.register_manager.unlockReg(lock);
        reg_locks.deinit();
    };

    for (
        0..,
        self.register_manager.registers,
        state.registers,
        state.reg_tracking,
    ) |reg_i, current_slot, target_slot, reg_tracking| {
        const reg_index: RegisterManager.TrackedIndex = @intCast(reg_i);
        const current_maybe_inst = if (self.register_manager.isRegIndexFree(reg_index)) null else current_slot;
        const target_maybe_inst = if (state.free_registers.isSet(reg_index)) null else target_slot;
        if (std.debug.runtime_safety) if (target_maybe_inst) |target_inst|
            assert(self.inst_tracking.getIndex(target_inst).? < state.inst_tracking_len);
        if (opts.emit_instructions and current_maybe_inst != target_maybe_inst) {
            if (current_maybe_inst) |current_inst|
                try self.inst_tracking.getPtr(current_inst).?.spill(self, current_inst);
            if (target_maybe_inst) |target_inst|
                try self.inst_tracking.getPtr(target_inst).?.materialize(self, target_inst, reg_tracking);
        }
        if (opts.update_tracking) {
            if (current_maybe_inst) |current_inst| {
                try self.inst_tracking.getPtr(current_inst).?.trackSpill(self, current_inst);
                self.register_manager.freeRegIndex(reg_index);
            }
            if (target_maybe_inst) |target_inst| {
                self.register_manager.getRegIndexAssumeFree(reg_index, target_inst);
                self.inst_tracking.getPtr(target_inst).?.trackMaterialize(target_inst, reg_tracking);
            }
        } else if (target_maybe_inst) |_|
            try reg_locks.append(self.register_manager.lockRegIndexAssumeUnused(reg_index));
    }
    if (opts.emit_instructions) if (self.eflags_inst) |inst|
        try self.inst_tracking.getPtr(inst).?.spill(self, inst);
    if (opts.update_tracking) if (self.eflags_inst) |inst| {
        self.eflags_inst = null;
        try self.inst_tracking.getPtr(inst).?.trackSpill(self, inst);
    };

    if (opts.update_tracking and std.debug.runtime_safety) {
        assert(self.eflags_inst == null);
        assert(self.register_manager.free_registers.eql(state.free_registers));
        var used_reg_it = state.free_registers.iterator(.{ .kind = .unset });
        while (used_reg_it.next()) |index|
            assert(self.register_manager.registers[index] == state.registers[index]);
    }
}

pub fn spillInstruction(self: *CodeGen, reg: Register, inst: Air.Inst.Index) !void {
    const tracking = self.inst_tracking.getPtr(inst) orelse return;
    for (tracking.getRegs()) |tracked_reg| {
        if (tracked_reg.id() == reg.id()) break;
    } else unreachable; // spilled reg not tracked with spilled instruction
    try tracking.spill(self, inst);
    try tracking.trackSpill(self, inst);
}

pub fn spillEflagsIfOccupied(self: *CodeGen) !void {
    if (self.eflags_inst) |inst| {
        self.eflags_inst = null;
        const tracking = self.inst_tracking.getPtr(inst).?;
        assert(tracking.getCondition() != null);
        try tracking.spill(self, inst);
        try tracking.trackSpill(self, inst);
    }
}

pub fn spillCallerPreservedRegs(self: *CodeGen, cc: std.builtin.CallingConvention.Tag, ignore_reg: Register) !void {
    switch (cc) {
        inline .auto, .x86_64_sysv, .x86_64_win => |tag| inline for (comptime abi.getCallerPreservedRegs(tag)) |reg|
            if (reg != ignore_reg) try self.register_manager.getKnownReg(reg, null),
        else => unreachable,
    }
}

pub fn spillRegisters(self: *CodeGen, comptime registers: []const Register) !void {
    inline for (registers) |reg| try self.register_manager.getKnownReg(reg, null);
}

/// Copies a value to a register without tracking the register. The register is not considered
/// allocated. A second call to `copyToTmpRegister` may return the same register.
/// This can have a side effect of spilling instructions to the stack to free up a register.
fn copyToTmpRegister(self: *CodeGen, ty: Type, mcv: MCValue) !Register {
    const reg = try self.register_manager.allocReg(null, self.regSetForType(ty));
    try self.genSetReg(reg, ty, mcv, .{});
    return reg;
}

/// Allocates a new register and copies `mcv` into it.
/// `reg_owner` is the instruction that gets associated with the register in the register table.
/// This can have a side effect of spilling instructions to the stack to free up a register.
/// WARNING make sure that the allocated register matches the returned MCValue from an instruction!
fn copyToRegisterWithInstTracking(
    self: *CodeGen,
    reg_owner: Air.Inst.Index,
    ty: Type,
    mcv: MCValue,
) !MCValue {
    const reg: Register = try self.register_manager.allocReg(reg_owner, self.regSetForType(ty));
    try self.genSetReg(reg, ty, mcv, .{});
    return MCValue{ .register = reg };
}

fn genUnwrapErrUnionPayloadMir(
    self: *CodeGen,
    maybe_inst: ?Air.Inst.Index,
    err_union_ty: Type,
    err_union: MCValue,
) !MCValue {
    const pt = self.pt;
    const zcu = pt.zcu;
    const payload_ty = err_union_ty.errorUnionPayload(zcu);

    const result: MCValue = result: {
        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result .none;

        const payload_off: u31 = @intCast(codegen.errUnionPayloadOffset(payload_ty, zcu));
        switch (err_union) {
            .load_frame => |frame_addr| break :result .{ .load_frame = .{
                .index = frame_addr.index,
                .off = frame_addr.off + payload_off,
            } },
            .register => |reg| {
                // TODO reuse operand
                const eu_lock = self.register_manager.lockReg(reg);
                defer if (eu_lock) |lock| self.register_manager.unlockReg(lock);

                const payload_in_gp = self.regSetForType(payload_ty).supersetOf(abi.RegisterClass.gp);
                const result_mcv: MCValue = if (payload_in_gp and maybe_inst != null)
                    try self.copyToRegisterWithInstTracking(maybe_inst.?, err_union_ty, err_union)
                else
                    .{ .register = try self.copyToTmpRegister(err_union_ty, err_union) };
                if (payload_off > 0) try self.genShiftBinOpMir(
                    .{ ._r, .sh },
                    err_union_ty,
                    result_mcv,
                    .u8,
                    .{ .immediate = @as(u6, @intCast(payload_off * 8)) },
                ) else try self.truncateRegister(payload_ty, result_mcv.register);
                break :result if (payload_in_gp)
                    result_mcv
                else if (maybe_inst) |inst|
                    try self.copyToRegisterWithInstTracking(inst, payload_ty, result_mcv)
                else
                    .{ .register = try self.copyToTmpRegister(payload_ty, result_mcv) };
            },
            else => return self.fail("TODO implement genUnwrapErrUnionPayloadMir for {f}", .{err_union}),
        }
    };

    return result;
}

fn genUnwrapErrUnionPayloadPtrMir(
    self: *CodeGen,
    maybe_inst: ?Air.Inst.Index,
    ptr_ty: Type,
    ptr_mcv: MCValue,
) !MCValue {
    const pt = self.pt;
    const zcu = pt.zcu;
    const err_union_ty = ptr_ty.childType(zcu);
    const payload_ty = err_union_ty.errorUnionPayload(zcu);

    const result: MCValue = result: {
        const payload_off = codegen.errUnionPayloadOffset(payload_ty, zcu);
        const result_mcv: MCValue = if (maybe_inst) |inst|
            try self.copyToRegisterWithInstTracking(inst, ptr_ty, ptr_mcv)
        else
            .{ .register = try self.copyToTmpRegister(ptr_ty, ptr_mcv) };
        try self.genBinOpMir(.{ ._, .add }, ptr_ty, result_mcv, .{ .immediate = payload_off });
        break :result result_mcv;
    };

    return result;
}

fn reuseOperand(
    self: *CodeGen,
    inst: Air.Inst.Index,
    operand: Air.Inst.Ref,
    op_index: Air.Liveness.OperandInt,
    mcv: MCValue,
) bool {
    return self.reuseOperandAdvanced(inst, operand, op_index, mcv, inst);
}

fn reuseOperandAdvanced(
    self: *CodeGen,
    inst: Air.Inst.Index,
    operand: Air.Inst.Ref,
    op_index: Air.Liveness.OperandInt,
    mcv: MCValue,
    maybe_tracked_inst: ?Air.Inst.Index,
) bool {
    if (!self.liveness.operandDies(inst, op_index))
        return false;

    switch (mcv) {
        .register, .register_pair, .register_overflow, .register_mask => for (mcv.getRegs()) |reg| {
            // If it's in the registers table, need to associate the register(s) with the
            // new instruction.
            if (maybe_tracked_inst) |tracked_inst| {
                if (!self.register_manager.isRegFree(reg)) {
                    if (RegisterManager.indexOfRegIntoTracked(reg)) |index| {
                        self.register_manager.registers[index] = tracked_inst;
                    }
                }
            } else self.register_manager.freeReg(reg);
        },
        .load_frame => |frame_addr| if (frame_addr.index.isNamed()) return false,
        else => return false,
    }
    switch (mcv) {
        .eflags, .register_overflow => self.eflags_inst = maybe_tracked_inst,
        else => {},
    }

    // Prevent the operand deaths processing code from deallocating it.
    self.reused_operands.set(op_index);
    const op_inst = operand.toIndex().?;
    self.getResolvedInstValue(op_inst).reuse(self, maybe_tracked_inst, op_inst);

    return true;
}

fn load(self: *CodeGen, dst_mcv: MCValue, ptr_ty: Type, ptr_mcv: MCValue) InnerError!void {
    const pt = self.pt;
    const zcu = pt.zcu;
    const dst_ty = ptr_ty.childType(zcu);
    if (!dst_ty.hasRuntimeBitsIgnoreComptime(zcu)) return;
    switch (ptr_mcv) {
        .none,
        .unreach,
        .dead,
        .undef,
        .eflags,
        .register_pair,
        .register_triple,
        .register_quadruple,
        .register_overflow,
        .register_mask,
        .indirect_load_frame,
        .elementwise_args,
        .reserved_frame,
        => unreachable, // not a valid pointer
        .immediate,
        .register,
        .register_offset,
        .lea_frame,
        .lea_nav,
        .lea_uav,
        .lea_lazy_sym,
        .lea_extern_func,
        => try self.genCopy(dst_ty, dst_mcv, ptr_mcv.deref(), .{}),
        .memory,
        .indirect,
        .load_frame,
        .load_nav,
        .load_uav,
        .load_lazy_sym,
        .load_extern_func,
        => {
            const addr_reg = try self.copyToTmpRegister(ptr_ty, ptr_mcv);
            const addr_lock = self.register_manager.lockRegAssumeUnused(addr_reg);
            defer self.register_manager.unlockReg(addr_lock);

            try self.genCopy(dst_ty, dst_mcv, .{ .indirect = .{ .reg = addr_reg } }, .{});
        },
        .air_ref => |ptr_ref| try self.load(dst_mcv, ptr_ty, try self.resolveInst(ptr_ref)),
    }
}

fn store(
    self: *CodeGen,
    ptr_ty: Type,
    ptr_mcv: MCValue,
    src_mcv: MCValue,
    opts: CopyOptions,
) InnerError!void {
    const pt = self.pt;
    const zcu = pt.zcu;
    const src_ty = ptr_ty.childType(zcu);
    if (!src_ty.hasRuntimeBitsIgnoreComptime(zcu)) return;
    switch (ptr_mcv) {
        .none,
        .unreach,
        .dead,
        .undef,
        .eflags,
        .register_pair,
        .register_triple,
        .register_quadruple,
        .register_overflow,
        .register_mask,
        .indirect_load_frame,
        .elementwise_args,
        .reserved_frame,
        => unreachable, // not a valid pointer
        .immediate,
        .register,
        .register_offset,
        .lea_frame,
        .lea_nav,
        .lea_uav,
        .lea_lazy_sym,
        .lea_extern_func,
        => try self.genCopy(src_ty, ptr_mcv.deref(), src_mcv, opts),
        .memory,
        .indirect,
        .load_frame,
        .load_nav,
        .load_uav,
        .load_lazy_sym,
        .load_extern_func,
        => {
            const addr_reg = try self.copyToTmpRegister(ptr_ty, ptr_mcv);
            const addr_lock = self.register_manager.lockRegAssumeUnused(addr_reg);
            defer self.register_manager.unlockReg(addr_lock);

            try self.genCopy(src_ty, .{ .indirect = .{ .reg = addr_reg } }, src_mcv, opts);
        },
        .air_ref => |ptr_ref| try self.store(ptr_ty, try self.resolveInst(ptr_ref), src_mcv, opts),
    }
}

fn genUnOpMir(self: *CodeGen, mir_tag: Mir.Inst.FixedTag, dst_ty: Type, dst_mcv: MCValue) !void {
    const pt = self.pt;
    const abi_size: u32 = @intCast(dst_ty.abiSize(pt.zcu));
    if (abi_size > 8) return self.fail("TODO implement {} for {f}", .{ mir_tag, dst_ty.fmt(pt) });
    switch (dst_mcv) {
        .none,
        .unreach,
        .dead,
        .undef,
        .immediate,
        .register_offset,
        .eflags,
        .register_overflow,
        .register_mask,
        .indirect_load_frame,
        .lea_frame,
        .lea_nav,
        .lea_uav,
        .lea_lazy_sym,
        .lea_extern_func,
        .elementwise_args,
        .reserved_frame,
        .air_ref,
        => unreachable, // unmodifiable destination
        .register => |dst_reg| try self.asmRegister(mir_tag, registerAlias(dst_reg, abi_size)),
        .register_pair, .register_triple, .register_quadruple => unreachable, // unimplemented
        .memory, .load_nav, .load_uav, .load_lazy_sym, .load_extern_func => {
            const addr_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp);
            const addr_reg_lock = self.register_manager.lockRegAssumeUnused(addr_reg);
            defer self.register_manager.unlockReg(addr_reg_lock);

            try self.genSetReg(addr_reg, .usize, dst_mcv.address(), .{});
            try self.asmMemory(mir_tag, .{ .base = .{ .reg = addr_reg }, .mod = .{ .rm = .{
                .size = .fromSize(abi_size),
            } } });
        },
        .indirect, .load_frame => try self.asmMemory(
            mir_tag,
            try dst_mcv.mem(self, .{ .size = .fromSize(abi_size) }),
        ),
    }
}

/// Clobbers .rcx for non-immediate shift value.
fn genShiftBinOpMir(
    self: *CodeGen,
    tag: Mir.Inst.FixedTag,
    lhs_ty: Type,
    lhs_mcv: MCValue,
    rhs_ty: Type,
    rhs_mcv: MCValue,
) !void {
    const pt = self.pt;
    const zcu = pt.zcu;
    const abi_size: u31 = @intCast(lhs_ty.abiSize(zcu));
    const shift_abi_size: u32 = @intCast(rhs_ty.abiSize(zcu));
    try self.spillEflagsIfOccupied();

    if (abi_size > 16) {
        const limbs_len = std.math.divCeil(u32, abi_size, 8) catch unreachable;
        assert(shift_abi_size >= 1 and shift_abi_size <= 2);

        const rcx_lock: ?RegisterLock = switch (rhs_mcv) {
            .immediate => |shift_imm| switch (shift_imm) {
                0 => return,
                else => null,
            },
            else => lock: {
                if (switch (rhs_mcv) {
                    .register => |rhs_reg| rhs_reg.id() != Register.rcx.id(),
                    else => true,
                }) {
                    self.register_manager.getRegAssumeFree(.rcx, null);
                    try self.genSetReg(.rcx, rhs_ty, rhs_mcv, .{});
                }
                break :lock self.register_manager.lockReg(.rcx);
            },
        };
        defer if (rcx_lock) |lock| self.register_manager.unlockReg(lock);

        const temp_regs = try self.register_manager.allocRegs(4, @splat(null), abi.RegisterClass.gp);
        const temp_locks = self.register_manager.lockRegsAssumeUnused(4, temp_regs);
        defer for (temp_locks) |lock| self.register_manager.unlockReg(lock);

        switch (tag[0]) {
            ._l => {
                try self.asmRegisterImmediate(.{ ._, .mov }, temp_regs[1].to32(), .u(limbs_len - 1));
                switch (rhs_mcv) {
                    .immediate => |shift_imm| try self.asmRegisterImmediate(
                        .{ ._, .mov },
                        temp_regs[0].to32(),
                        .u(limbs_len - (shift_imm >> 6) - 1),
                    ),
                    else => {
                        try self.asmRegisterRegister(
                            .{ ._, .movzx },
                            temp_regs[2].to32(),
                            registerAlias(.rcx, shift_abi_size),
                        );
                        try self.asmRegisterImmediate(.{ ._, .@"and" }, .cl, .u(std.math.maxInt(u6)));
                        try self.asmRegisterImmediate(.{ ._r, .sh }, temp_regs[2].to32(), .u(6));
                        try self.asmRegisterRegister(
                            .{ ._, .mov },
                            temp_regs[0].to32(),
                            temp_regs[1].to32(),
                        );
                        try self.asmRegisterRegister(
                            .{ ._, .sub },
                            temp_regs[0].to32(),
                            temp_regs[2].to32(),
                        );
                    },
                }
            },
            ._r => {
                try self.asmRegisterRegister(.{ ._, .xor }, temp_regs[1].to32(), temp_regs[1].to32());
                switch (rhs_mcv) {
                    .immediate => |shift_imm| try self.asmRegisterImmediate(
                        .{ ._, .mov },
                        temp_regs[0].to32(),
                        .u(shift_imm >> 6),
                    ),
                    else => {
                        try self.asmRegisterRegister(
                            .{ ._, .movzx },
                            temp_regs[0].to32(),
                            registerAlias(.rcx, shift_abi_size),
                        );
                        try self.asmRegisterImmediate(.{ ._, .@"and" }, .cl, .u(std.math.maxInt(u6)));
                        try self.asmRegisterImmediate(.{ ._r, .sh }, temp_regs[0].to32(), .u(6));
                    },
                }
            },
            else => unreachable,
        }

        const slow_inc_dec = self.hasFeature(.slow_incdec);
        if (switch (rhs_mcv) {
            .immediate => |shift_imm| shift_imm >> 6 < limbs_len - 1,
            else => true,
        }) {
            try self.asmRegisterMemory(.{ ._, .mov }, temp_regs[2].to64(), .{
                .base = .{ .frame = lhs_mcv.load_frame.index },
                .mod = .{ .rm = .{
                    .size = .qword,
                    .index = temp_regs[0].to64(),
                    .scale = .@"8",
                    .disp = lhs_mcv.load_frame.off,
                } },
            });
            const skip = switch (rhs_mcv) {
                .immediate => undefined,
                else => switch (tag[0]) {
                    ._l => try self.asmJccReloc(.z, undefined),
                    ._r => skip: {
                        try self.asmRegisterImmediate(
                            .{ ._, .cmp },
                            temp_regs[0].to32(),
                            .u(limbs_len - 1),
                        );
                        break :skip try self.asmJccReloc(.nb, undefined);
                    },
                    else => unreachable,
                },
            };
            const loop: Mir.Inst.Index = @intCast(self.mir_instructions.len);
            try self.asmRegisterMemory(.{ ._, .mov }, temp_regs[3].to64(), .{
                .base = .{ .frame = lhs_mcv.load_frame.index },
                .mod = .{ .rm = .{
                    .size = .qword,
                    .index = temp_regs[0].to64(),
                    .scale = .@"8",
                    .disp = switch (tag[0]) {
                        ._l => lhs_mcv.load_frame.off - 8,
                        ._r => lhs_mcv.load_frame.off + 8,
                        else => unreachable,
                    },
                } },
            });
            switch (rhs_mcv) {
                .immediate => |shift_imm| try self.asmRegisterRegisterImmediate(
                    .{ switch (tag[0]) {
                        ._l => ._ld,
                        ._r => ._rd,
                        else => unreachable,
                    }, .sh },
                    temp_regs[2].to64(),
                    temp_regs[3].to64(),
                    .u(shift_imm & std.math.maxInt(u6)),
                ),
                else => try self.asmRegisterRegisterRegister(.{ switch (tag[0]) {
                    ._l => ._ld,
                    ._r => ._rd,
                    else => unreachable,
                }, .sh }, temp_regs[2].to64(), temp_regs[3].to64(), .cl),
            }
            try self.asmMemoryRegister(.{ ._, .mov }, .{
                .base = .{ .frame = lhs_mcv.load_frame.index },
                .mod = .{ .rm = .{
                    .size = .qword,
                    .index = temp_regs[1].to64(),
                    .scale = .@"8",
                    .disp = lhs_mcv.load_frame.off,
                } },
            }, temp_regs[2].to64());
            try self.asmRegisterRegister(.{ ._, .mov }, temp_regs[2].to64(), temp_regs[3].to64());
            switch (tag[0]) {
                ._l => {
                    if (slow_inc_dec) {
                        try self.asmRegisterImmediate(.{ ._, .sub }, temp_regs[1].to32(), .u(1));
                        try self.asmRegisterImmediate(.{ ._, .sub }, temp_regs[0].to32(), .u(1));
                    } else {
                        try self.asmRegister(.{ ._c, .de }, temp_regs[1].to32());
                        try self.asmRegister(.{ ._c, .de }, temp_regs[0].to32());
                    }
                    _ = try self.asmJccReloc(.nz, loop);
                },
                ._r => {
                    if (slow_inc_dec) {
                        try self.asmRegisterImmediate(.{ ._, .add }, temp_regs[1].to32(), .u(1));
                        try self.asmRegisterImmediate(.{ ._, .add }, temp_regs[0].to32(), .u(1));
                    } else {
                        try self.asmRegister(.{ ._c, .in }, temp_regs[1].to32());
                        try self.asmRegister(.{ ._c, .in }, temp_regs[0].to32());
                    }
                    try self.asmRegisterImmediate(
                        .{ ._, .cmp },
                        temp_regs[0].to32(),
                        .u(limbs_len - 1),
                    );
                    _ = try self.asmJccReloc(.b, loop);
                },
                else => unreachable,
            }
            switch (rhs_mcv) {
                .immediate => {},
                else => self.performReloc(skip),
            }
        } else try self.asmRegisterMemory(.{ ._, .mov }, temp_regs[2].to64(), .{
            .base = .{ .frame = lhs_mcv.load_frame.index },
            .mod = .{ .rm = .{
                .size = .qword,
                .disp = switch (tag[0]) {
                    ._l => lhs_mcv.load_frame.off,
                    ._r => lhs_mcv.load_frame.off + abi_size - 8,
                    else => unreachable,
                },
            } },
        });
        switch (rhs_mcv) {
            .immediate => |shift_imm| try self.asmRegisterImmediate(
                tag,
                temp_regs[2].to64(),
                .u(shift_imm & std.math.maxInt(u6)),
            ),
            else => try self.asmRegisterRegister(tag, temp_regs[2].to64(), .cl),
        }
        try self.asmMemoryRegister(.{ ._, .mov }, .{
            .base = .{ .frame = lhs_mcv.load_frame.index },
            .mod = .{ .rm = .{
                .size = .qword,
                .index = temp_regs[1].to64(),
                .scale = .@"8",
                .disp = lhs_mcv.load_frame.off,
            } },
        }, temp_regs[2].to64());
        if (tag[0] == ._r and tag[1] == .sa) try self.asmRegisterImmediate(
            tag,
            temp_regs[2].to64(),
            .u(63),
        );
        if (switch (rhs_mcv) {
            .immediate => |shift_imm| shift_imm >> 6 > 0,
            else => true,
        }) {
            const skip = switch (rhs_mcv) {
                .immediate => undefined,
                else => switch (tag[0]) {
                    ._l => skip: {
                        try self.asmRegisterRegister(
                            .{ ._, .@"test" },
                            temp_regs[1].to32(),
                            temp_regs[1].to32(),
                        );
                        break :skip try self.asmJccReloc(.z, undefined);
                    },
                    ._r => skip: {
                        try self.asmRegisterImmediate(
                            .{ ._, .cmp },
                            temp_regs[1].to32(),
                            .u(limbs_len - 1),
                        );
                        break :skip try self.asmJccReloc(.nb, undefined);
                    },
                    else => unreachable,
                },
            };
            const loop: Mir.Inst.Index = @intCast(self.mir_instructions.len);
            switch (tag[0]) {
                ._l => if (slow_inc_dec) {
                    try self.asmRegisterImmediate(.{ ._, .sub }, temp_regs[1].to32(), .u(1));
                } else {
                    try self.asmRegister(.{ ._c, .de }, temp_regs[1].to32());
                },
                ._r => if (slow_inc_dec) {
                    try self.asmRegisterImmediate(.{ ._, .add }, temp_regs[1].to32(), .u(1));
                } else {
                    try self.asmRegister(.{ ._c, .in }, temp_regs[1].to32());
                },
                else => unreachable,
            }
            if (tag[0] == ._r and tag[1] == .sa) try self.asmMemoryRegister(.{ ._, .mov }, .{
                .base = .{ .frame = lhs_mcv.load_frame.index },
                .mod = .{ .rm = .{
                    .size = .qword,
                    .index = temp_regs[1].to64(),
                    .scale = .@"8",
                    .disp = lhs_mcv.load_frame.off,
                } },
            }, temp_regs[2].to64()) else try self.asmMemoryImmediate(.{ ._, .mov }, .{
                .base = .{ .frame = lhs_mcv.load_frame.index },
                .mod = .{ .rm = .{
                    .size = .qword,
                    .index = temp_regs[1].to64(),
                    .scale = .@"8",
                    .disp = lhs_mcv.load_frame.off,
                } },
            }, .u(0));
            switch (tag[0]) {
                ._l => _ = try self.asmJccReloc(.nz, loop),
                ._r => {
                    try self.asmRegisterImmediate(
                        .{ ._, .cmp },
                        temp_regs[1].to32(),
                        .u(limbs_len - 1),
                    );
                    _ = try self.asmJccReloc(.b, loop);
                },
                else => unreachable,
            }
            switch (rhs_mcv) {
                .immediate => {},
                else => self.performReloc(skip),
            }
        }
        return;
    }

    assert(shift_abi_size == 1);
    const shift_mcv: MCValue = shift: {
        switch (rhs_mcv) {
            .immediate => |shift_imm| switch (shift_imm) {
                0 => return,
                else => break :shift rhs_mcv,
            },
            .register => |rhs_reg| if (rhs_reg.id() == Register.rcx.id())
                break :shift rhs_mcv,
            else => {},
        }
        self.register_manager.getRegAssumeFree(.rcx, null);
        try self.genSetReg(.cl, rhs_ty, rhs_mcv, .{});
        break :shift .{ .register = .rcx };
    };
    if (abi_size > 8) {
        const info: struct { indices: [2]u31, double_tag: Mir.Inst.FixedTag } = switch (tag[0]) {
            ._l => .{ .indices = .{ 0, 1 }, .double_tag = .{ ._ld, .sh } },
            ._r => .{ .indices = .{ 1, 0 }, .double_tag = .{ ._rd, .sh } },
            else => unreachable,
        };
        switch (lhs_mcv) {
            .register_pair => |lhs_regs| switch (shift_mcv) {
                .immediate => |shift_imm| if (shift_imm > 0 and shift_imm < 64) {
                    try self.asmRegisterRegisterImmediate(
                        info.double_tag,
                        lhs_regs[info.indices[1]],
                        lhs_regs[info.indices[0]],
                        .u(shift_imm),
                    );
                    try self.asmRegisterImmediate(
                        tag,
                        lhs_regs[info.indices[0]],
                        .u(shift_imm),
                    );
                    return;
                } else {
                    assert(shift_imm < 128);
                    try self.asmRegisterRegister(
                        .{ ._, .mov },
                        lhs_regs[info.indices[1]],
                        lhs_regs[info.indices[0]],
                    );
                    if (tag[0] == ._r and tag[1] == .sa) try self.asmRegisterImmediate(
                        tag,
                        lhs_regs[info.indices[0]],
                        .u(63),
                    ) else try self.asmRegisterRegister(
                        .{ ._, .xor },
                        lhs_regs[info.indices[0]],
                        lhs_regs[info.indices[0]],
                    );
                    if (shift_imm > 64) try self.asmRegisterImmediate(
                        tag,
                        lhs_regs[info.indices[1]],
                        .u(shift_imm - 64),
                    );
                    return;
                },
                .register => |shift_reg| {
                    const tmp_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp);
                    const tmp_lock = self.register_manager.lockRegAssumeUnused(tmp_reg);
                    defer self.register_manager.unlockReg(tmp_lock);

                    if (tag[0] == ._r and tag[1] == .sa) {
                        try self.asmRegisterRegister(.{ ._, .mov }, tmp_reg, lhs_regs[info.indices[0]]);
                        try self.asmRegisterImmediate(tag, tmp_reg, .u(63));
                    } else try self.asmRegisterRegister(
                        .{ ._, .xor },
                        tmp_reg.to32(),
                        tmp_reg.to32(),
                    );
                    try self.asmRegisterRegisterRegister(
                        info.double_tag,
                        lhs_regs[info.indices[1]],
                        lhs_regs[info.indices[0]],
                        shift_reg.to8(),
                    );
                    try self.asmRegisterRegister(
                        tag,
                        lhs_regs[info.indices[0]],
                        shift_reg.to8(),
                    );
                    try self.asmRegisterImmediate(.{ ._, .cmp }, shift_reg.to8(), .u(64));
                    try self.asmCmovccRegisterRegister(
                        .ae,
                        lhs_regs[info.indices[1]],
                        lhs_regs[info.indices[0]],
                    );
                    try self.asmCmovccRegisterRegister(.ae, lhs_regs[info.indices[0]], tmp_reg);
                    return;
                },
                else => {},
            },
            .load_frame => |dst_frame_addr| {
                const tmp_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp);
                const tmp_lock = self.register_manager.lockRegAssumeUnused(tmp_reg);
                defer self.register_manager.unlockReg(tmp_lock);

                switch (shift_mcv) {
                    .immediate => |shift_imm| if (shift_imm > 0 and shift_imm < 64) {
                        try self.asmRegisterMemory(
                            .{ ._, .mov },
                            tmp_reg,
                            .{
                                .base = .{ .frame = dst_frame_addr.index },
                                .mod = .{ .rm = .{
                                    .size = .qword,
                                    .disp = dst_frame_addr.off + info.indices[0] * 8,
                                } },
                            },
                        );
                        try self.asmMemoryRegisterImmediate(
                            info.double_tag,
                            .{
                                .base = .{ .frame = dst_frame_addr.index },
                                .mod = .{ .rm = .{
                                    .size = .qword,
                                    .disp = dst_frame_addr.off + info.indices[1] * 8,
                                } },
                            },
                            tmp_reg,
                            .u(shift_imm),
                        );
                        try self.asmMemoryImmediate(
                            tag,
                            .{
                                .base = .{ .frame = dst_frame_addr.index },
                                .mod = .{ .rm = .{
                                    .size = .qword,
                                    .disp = dst_frame_addr.off + info.indices[0] * 8,
                                } },
                            },
                            .u(shift_imm),
                        );
                        return;
                    } else {
                        assert(shift_imm < 128);
                        try self.asmRegisterMemory(
                            .{ ._, .mov },
                            tmp_reg,
                            .{
                                .base = .{ .frame = dst_frame_addr.index },
                                .mod = .{ .rm = .{
                                    .size = .qword,
                                    .disp = dst_frame_addr.off + info.indices[0] * 8,
                                } },
                            },
                        );
                        if (shift_imm > 64) try self.asmRegisterImmediate(
                            tag,
                            tmp_reg,
                            .u(shift_imm - 64),
                        );
                        try self.asmMemoryRegister(
                            .{ ._, .mov },
                            .{
                                .base = .{ .frame = dst_frame_addr.index },
                                .mod = .{ .rm = .{
                                    .size = .qword,
                                    .disp = dst_frame_addr.off + info.indices[1] * 8,
                                } },
                            },
                            tmp_reg,
                        );
                        if (tag[0] == ._r and tag[1] == .sa) try self.asmMemoryImmediate(
                            tag,
                            .{
                                .base = .{ .frame = dst_frame_addr.index },
                                .mod = .{ .rm = .{
                                    .size = .qword,
                                    .disp = dst_frame_addr.off + info.indices[0] * 8,
                                } },
                            },
                            .u(63),
                        ) else {
                            try self.asmRegisterRegister(.{ ._, .xor }, tmp_reg.to32(), tmp_reg.to32());
                            try self.asmMemoryRegister(
                                .{ ._, .mov },
                                .{
                                    .base = .{ .frame = dst_frame_addr.index },
                                    .mod = .{ .rm = .{
                                        .size = .qword,
                                        .disp = dst_frame_addr.off + info.indices[0] * 8,
                                    } },
                                },
                                tmp_reg,
                            );
                        }
                        return;
                    },
                    .register => |shift_reg| {
                        const first_reg =
                            try self.register_manager.allocReg(null, abi.RegisterClass.gp);
                        const first_lock = self.register_manager.lockRegAssumeUnused(first_reg);
                        defer self.register_manager.unlockReg(first_lock);

                        const second_reg =
                            try self.register_manager.allocReg(null, abi.RegisterClass.gp);
                        const second_lock = self.register_manager.lockRegAssumeUnused(second_reg);
                        defer self.register_manager.unlockReg(second_lock);

                        try self.asmRegisterMemory(
                            .{ ._, .mov },
                            first_reg,
                            .{
                                .base = .{ .frame = dst_frame_addr.index },
                                .mod = .{ .rm = .{
                                    .size = .qword,
                                    .disp = dst_frame_addr.off + info.indices[0] * 8,
                                } },
                            },
                        );
                        try self.asmRegisterMemory(
                            .{ ._, .mov },
                            second_reg,
                            .{
                                .base = .{ .frame = dst_frame_addr.index },
                                .mod = .{ .rm = .{
                                    .size = .qword,
                                    .disp = dst_frame_addr.off + info.indices[1] * 8,
                                } },
                            },
                        );
                        if (tag[0] == ._r and tag[1] == .sa) {
                            try self.asmRegisterRegister(.{ ._, .mov }, tmp_reg, first_reg);
                            try self.asmRegisterImmediate(tag, tmp_reg, .u(63));
                        } else try self.asmRegisterRegister(
                            .{ ._, .xor },
                            tmp_reg.to32(),
                            tmp_reg.to32(),
                        );
                        try self.asmRegisterRegisterRegister(
                            info.double_tag,
                            second_reg,
                            first_reg,
                            shift_reg.to8(),
                        );
                        try self.asmRegisterRegister(tag, first_reg, shift_reg.to8());
                        try self.asmRegisterImmediate(
                            .{ ._, .cmp },
                            shift_reg.to8(),
                            .u(64),
                        );
                        try self.asmCmovccRegisterRegister(.ae, second_reg, first_reg);
                        try self.asmCmovccRegisterRegister(.ae, first_reg, tmp_reg);
                        try self.asmMemoryRegister(
                            .{ ._, .mov },
                            .{
                                .base = .{ .frame = dst_frame_addr.index },
                                .mod = .{ .rm = .{
                                    .size = .qword,
                                    .disp = dst_frame_addr.off + info.indices[1] * 8,
                                } },
                            },
                            second_reg,
                        );
                        try self.asmMemoryRegister(
                            .{ ._, .mov },
                            .{
                                .base = .{ .frame = dst_frame_addr.index },
                                .mod = .{ .rm = .{
                                    .size = .qword,
                                    .disp = dst_frame_addr.off + info.indices[0] * 8,
                                } },
                            },
                            first_reg,
                        );
                        return;
                    },
                    else => {},
                }
            },
            else => {},
        }
    } else switch (lhs_mcv) {
        .register => |lhs_reg| switch (shift_mcv) {
            .immediate => |shift_imm| return self.asmRegisterImmediate(
                tag,
                registerAlias(lhs_reg, abi_size),
                .u(shift_imm),
            ),
            .register => |shift_reg| return self.asmRegisterRegister(
                tag,
                registerAlias(lhs_reg, abi_size),
                shift_reg.to8(),
            ),
            else => {},
        },
        .memory, .indirect, .load_frame => {
            const lhs_mem: Memory = switch (lhs_mcv) {
                .memory => |addr| .{
                    .base = .{ .reg = .ds },
                    .mod = .{ .rm = .{
                        .size = .fromSize(abi_size),
                        .disp = std.math.cast(i32, @as(i64, @bitCast(addr))) orelse
                            return self.fail("TODO genShiftBinOpMir between {s} and {s}", .{
                                @tagName(lhs_mcv),
                                @tagName(shift_mcv),
                            }),
                    } },
                },
                .indirect => |reg_off| .{
                    .base = .{ .reg = reg_off.reg },
                    .mod = .{ .rm = .{
                        .size = .fromSize(abi_size),
                        .disp = reg_off.off,
                    } },
                },
                .load_frame => |frame_addr| .{
                    .base = .{ .frame = frame_addr.index },
                    .mod = .{ .rm = .{
                        .size = .fromSize(abi_size),
                        .disp = frame_addr.off,
                    } },
                },
                else => unreachable,
            };
            switch (shift_mcv) {
                .immediate => |shift_imm| return self.asmMemoryImmediate(tag, lhs_mem, .u(shift_imm)),
                .register => |shift_reg| return self.asmMemoryRegister(
                    tag,
                    lhs_mem,
                    shift_reg.to8(),
                ),
                else => {},
            }
        },
        else => {},
    }
    return self.fail("TODO genShiftBinOpMir between {s} and {s}", .{
        @tagName(lhs_mcv),
        @tagName(shift_mcv),
    });
}

fn genBinOpMir(
    self: *CodeGen,
    mir_tag: Mir.Inst.FixedTag,
    ty: Type,
    dst_mcv: MCValue,
    src_mcv: MCValue,
) !void {
    const pt = self.pt;
    const zcu = pt.zcu;
    const abi_size: u32 = @intCast(ty.abiSize(zcu));
    try self.spillEflagsIfOccupied();
    switch (dst_mcv) {
        .none,
        .unreach,
        .dead,
        .undef,
        .immediate,
        .eflags,
        .register_overflow,
        .register_mask,
        .lea_frame,
        .lea_nav,
        .lea_uav,
        .lea_lazy_sym,
        .lea_extern_func,
        .indirect_load_frame,
        .elementwise_args,
        .reserved_frame,
        .air_ref,
        => unreachable, // unmodifiable destination
        .register, .register_pair, .register_triple, .register_quadruple, .register_offset => {
            switch (dst_mcv) {
                .register, .register_pair, .register_triple, .register_quadruple => {},
                .register_offset => |ro| assert(ro.off == 0),
                else => unreachable,
            }
            for (dst_mcv.getRegs(), 0..) |dst_reg, dst_reg_i| {
                const dst_reg_lock = self.register_manager.lockReg(dst_reg);
                defer if (dst_reg_lock) |lock| self.register_manager.unlockReg(lock);

                const mir_limb_tag: Mir.Inst.FixedTag = switch (dst_reg_i) {
                    0 => mir_tag,
                    1 => switch (mir_tag[1]) {
                        .add => .{ ._, .adc },
                        .sub, .cmp => .{ ._, .sbb },
                        .@"or", .@"and", .xor => mir_tag,
                        else => return self.fail("TODO genBinOpMir implement large ABI for {s}", .{
                            @tagName(mir_tag[1]),
                        }),
                    },
                    else => unreachable,
                };
                const off: u4 = @intCast(dst_reg_i * 8);
                const limb_abi_size = @min(abi_size - off, 8);
                const dst_alias = registerAlias(dst_reg, limb_abi_size);
                switch (src_mcv) {
                    .none,
                    .unreach,
                    .dead,
                    .undef,
                    .register_overflow,
                    .register_mask,
                    .indirect_load_frame,
                    .elementwise_args,
                    .reserved_frame,
                    => unreachable,
                    .register,
                    .register_pair,
                    .register_triple,
                    .register_quadruple,
                    => try self.asmRegisterRegister(
                        mir_limb_tag,
                        dst_alias,
                        registerAlias(src_mcv.getRegs()[dst_reg_i], limb_abi_size),
                    ),
                    .immediate => |imm| {
                        assert(off == 0);
                        switch (self.regBitSize(ty)) {
                            8 => try self.asmRegisterImmediate(
                                mir_limb_tag,
                                dst_alias,
                                if (std.math.cast(i8, @as(i64, @bitCast(imm)))) |small|
                                    .s(small)
                                else
                                    .u(@as(u8, @intCast(imm))),
                            ),
                            16 => try self.asmRegisterImmediate(
                                mir_limb_tag,
                                dst_alias,
                                if (std.math.cast(i16, @as(i64, @bitCast(imm)))) |small|
                                    .s(small)
                                else
                                    .u(@as(u16, @intCast(imm))),
                            ),
                            32 => try self.asmRegisterImmediate(
                                mir_limb_tag,
                                dst_alias,
                                if (std.math.cast(i32, @as(i64, @bitCast(imm)))) |small|
                                    .s(small)
                                else
                                    .u(@as(u32, @intCast(imm))),
                            ),
                            64 => if (std.math.cast(i32, @as(i64, @bitCast(imm)))) |small|
                                try self.asmRegisterImmediate(mir_limb_tag, dst_alias, .s(small))
                            else
                                try self.asmRegisterRegister(mir_limb_tag, dst_alias, registerAlias(
                                    try self.copyToTmpRegister(ty, src_mcv),
                                    limb_abi_size,
                                )),
                            else => unreachable,
                        }
                    },
                    .eflags,
                    .register_offset,
                    .memory,
                    .indirect,
                    .load_frame,
                    .lea_frame,
                    .load_nav,
                    .lea_nav,
                    .load_uav,
                    .lea_uav,
                    .load_lazy_sym,
                    .lea_lazy_sym,
                    .load_extern_func,
                    .lea_extern_func,
                    => {
                        direct: {
                            try self.asmRegisterMemory(mir_limb_tag, dst_alias, switch (src_mcv) {
                                .memory => |addr| .{
                                    .base = .{ .reg = .ds },
                                    .mod = .{ .rm = .{
                                        .size = .fromSize(limb_abi_size),
                                        .disp = std.math.cast(i32, addr + off) orelse break :direct,
                                    } },
                                },
                                .indirect => |reg_off| .{
                                    .base = .{ .reg = reg_off.reg },
                                    .mod = .{ .rm = .{
                                        .size = .fromSize(limb_abi_size),
                                        .disp = reg_off.off + off,
                                    } },
                                },
                                .load_frame => |frame_addr| .{
                                    .base = .{ .frame = frame_addr.index },
                                    .mod = .{ .rm = .{
                                        .size = .fromSize(limb_abi_size),
                                        .disp = frame_addr.off + off,
                                    } },
                                },
                                else => break :direct,
                            });
                            continue;
                        }

                        switch (src_mcv) {
                            .eflags,
                            .register_offset,
                            .lea_frame,
                            .lea_nav,
                            .lea_uav,
                            .lea_lazy_sym,
                            .lea_extern_func,
                            => {
                                assert(off == 0);
                                const reg = try self.copyToTmpRegister(ty, src_mcv);
                                return self.genBinOpMir(
                                    mir_limb_tag,
                                    ty,
                                    dst_mcv,
                                    .{ .register = reg },
                                );
                            },
                            .memory,
                            .load_nav,
                            .load_uav,
                            .load_lazy_sym,
                            .load_extern_func,
                            => {
                                const ptr_ty = try pt.singleConstPtrType(ty);
                                const addr_reg = try self.copyToTmpRegister(ptr_ty, src_mcv.address());
                                return self.genBinOpMir(mir_limb_tag, ty, dst_mcv, .{
                                    .indirect = .{ .reg = addr_reg, .off = off },
                                });
                            },
                            else => unreachable,
                        }
                    },
                    .air_ref => |src_ref| return self.genBinOpMir(
                        mir_tag,
                        ty,
                        dst_mcv,
                        try self.resolveInst(src_ref),
                    ),
                }
            }
        },
        .memory,
        .indirect,
        .load_frame,
        .load_nav,
        .load_uav,
        .load_lazy_sym,
        .load_extern_func,
        => {
            const OpInfo = ?struct { addr_reg: Register, addr_lock: RegisterLock };
            const limb_abi_size: u32 = @min(abi_size, 8);

            const dst_info: OpInfo = switch (dst_mcv) {
                else => unreachable,
                .memory, .load_nav, .load_uav, .load_lazy_sym, .load_extern_func => dst: {
                    const dst_addr_reg =
                        (try self.register_manager.allocReg(null, abi.RegisterClass.gp)).to64();
                    const dst_addr_lock = self.register_manager.lockRegAssumeUnused(dst_addr_reg);
                    errdefer self.register_manager.unlockReg(dst_addr_lock);

                    try self.genSetReg(dst_addr_reg, .usize, dst_mcv.address(), .{});
                    break :dst .{ .addr_reg = dst_addr_reg, .addr_lock = dst_addr_lock };
                },
                .load_frame => null,
            };
            defer if (dst_info) |info| self.register_manager.unlockReg(info.addr_lock);

            const resolved_src_mcv = switch (src_mcv) {
                else => src_mcv,
                .air_ref => |src_ref| try self.resolveInst(src_ref),
            };
            const src_info: OpInfo = switch (resolved_src_mcv) {
                .none,
                .unreach,
                .dead,
                .undef,
                .register_overflow,
                .register_mask,
                .indirect_load_frame,
                .elementwise_args,
                .reserved_frame,
                .air_ref,
                => unreachable,
                .immediate,
                .eflags,
                .register,
                .register_pair,
                .register_triple,
                .register_quadruple,
                .register_offset,
                .indirect,
                .load_frame,
                .lea_frame,
                .lea_nav,
                .lea_uav,
                .lea_lazy_sym,
                .lea_extern_func,
                => null,
                .memory,
                .load_nav,
                .load_uav,
                .load_lazy_sym,
                .load_extern_func,
                => src: {
                    switch (resolved_src_mcv) {
                        .memory => |addr| if (std.math.cast(i32, @as(i64, @bitCast(addr))) != null and
                            std.math.cast(i32, @as(i64, @bitCast(addr)) + abi_size - limb_abi_size) != null)
                            break :src null,
                        .load_nav, .load_uav, .load_lazy_sym, .load_extern_func => {},
                        else => unreachable,
                    }

                    const src_addr_reg =
                        (try self.register_manager.allocReg(null, abi.RegisterClass.gp)).to64();
                    const src_addr_lock = self.register_manager.lockRegAssumeUnused(src_addr_reg);
                    errdefer self.register_manager.unlockReg(src_addr_lock);

                    try self.genSetReg(src_addr_reg, .usize, resolved_src_mcv.address(), .{});
                    break :src .{ .addr_reg = src_addr_reg, .addr_lock = src_addr_lock };
                },
            };
            defer if (src_info) |info| self.register_manager.unlockReg(info.addr_lock);

            const ty_signedness =
                if (ty.isAbiInt(zcu)) ty.intInfo(zcu).signedness else .unsigned;
            const limb_ty: Type = if (abi_size <= 8) ty else switch (ty_signedness) {
                .signed => .usize,
                .unsigned => .isize,
            };
            var limb_i: usize = 0;
            var off: i32 = 0;
            while (off < abi_size) : ({
                limb_i += 1;
                off += 8;
            }) {
                const mir_limb_tag: Mir.Inst.FixedTag = switch (limb_i) {
                    0 => mir_tag,
                    else => switch (mir_tag[1]) {
                        .add => .{ ._, .adc },
                        .sub, .cmp => .{ ._, .sbb },
                        .@"or", .@"and", .xor => mir_tag,
                        else => return self.fail("TODO genBinOpMir implement large ABI for {s}", .{
                            @tagName(mir_tag[1]),
                        }),
                    },
                };
                const dst_limb_mem: Memory = switch (dst_mcv) {
                    .memory,
                    .load_nav,
                    .load_uav,
                    .load_lazy_sym,
                    .load_extern_func,
                    => .{
                        .base = .{ .reg = dst_info.?.addr_reg },
                        .mod = .{ .rm = .{
                            .size = .fromSize(limb_abi_size),
                            .disp = off,
                        } },
                    },
                    .indirect => |reg_off| .{
                        .base = .{ .reg = reg_off.reg },
                        .mod = .{ .rm = .{
                            .size = .fromSize(limb_abi_size),
                            .disp = reg_off.off + off,
                        } },
                    },
                    .load_frame => |frame_addr| .{
                        .base = .{ .frame = frame_addr.index },
                        .mod = .{ .rm = .{
                            .size = .fromSize(limb_abi_size),
                            .disp = frame_addr.off + off,
                        } },
                    },
                    else => unreachable,
                };
                switch (resolved_src_mcv) {
                    .none,
                    .unreach,
                    .dead,
                    .undef,
                    .register_overflow,
                    .register_mask,
                    .indirect_load_frame,
                    .elementwise_args,
                    .reserved_frame,
                    .air_ref,
                    => unreachable,
                    .immediate => |src_imm| {
                        const imm: u64 = switch (limb_i) {
                            0 => src_imm,
                            else => switch (ty_signedness) {
                                .signed => @bitCast(@as(i64, @bitCast(src_imm)) >> 63),
                                .unsigned => 0,
                            },
                        };
                        switch (self.regBitSize(limb_ty)) {
                            8 => try self.asmMemoryImmediate(
                                mir_limb_tag,
                                dst_limb_mem,
                                if (std.math.cast(i8, @as(i64, @bitCast(imm)))) |small|
                                    .s(small)
                                else
                                    .u(@as(u8, @intCast(imm))),
                            ),
                            16 => try self.asmMemoryImmediate(
                                mir_limb_tag,
                                dst_limb_mem,
                                if (std.math.cast(i16, @as(i64, @bitCast(imm)))) |small|
                                    .s(small)
                                else
                                    .u(@as(u16, @intCast(imm))),
                            ),
                            32 => try self.asmMemoryImmediate(
                                mir_limb_tag,
                                dst_limb_mem,
                                if (std.math.cast(i32, @as(i64, @bitCast(imm)))) |small|
                                    .s(small)
                                else
                                    .u(@as(u32, @intCast(imm))),
                            ),
                            64 => if (std.math.cast(i32, @as(i64, @bitCast(imm)))) |small|
                                try self.asmMemoryImmediate(mir_limb_tag, dst_limb_mem, .s(small))
                            else
                                try self.asmMemoryRegister(
                                    mir_limb_tag,
                                    dst_limb_mem,
                                    registerAlias(
                                        try self.copyToTmpRegister(limb_ty, .{ .immediate = imm }),
                                        limb_abi_size,
                                    ),
                                ),
                            else => unreachable,
                        }
                    },
                    .register,
                    .register_pair,
                    .register_triple,
                    .register_quadruple,
                    .register_offset,
                    .eflags,
                    .memory,
                    .indirect,
                    .load_frame,
                    .lea_frame,
                    .load_nav,
                    .lea_nav,
                    .load_uav,
                    .lea_uav,
                    .load_lazy_sym,
                    .lea_lazy_sym,
                    .load_extern_func,
                    .lea_extern_func,
                    => {
                        const src_limb_mcv: MCValue = if (src_info) |info| .{
                            .indirect = .{ .reg = info.addr_reg, .off = off },
                        } else switch (resolved_src_mcv) {
                            .register, .register_pair, .register_triple, .register_quadruple => .{
                                .register = resolved_src_mcv.getRegs()[limb_i],
                            },
                            .eflags,
                            .register_offset,
                            .lea_frame,
                            .lea_nav,
                            .lea_uav,
                            .lea_lazy_sym,
                            .lea_extern_func,
                            => switch (limb_i) {
                                0 => resolved_src_mcv,
                                else => .{ .immediate = 0 },
                            },
                            .memory => |addr| .{ .memory = @bitCast(@as(i64, @bitCast(addr)) + off) },
                            .indirect => |reg_off| .{ .indirect = .{
                                .reg = reg_off.reg,
                                .off = reg_off.off + off,
                            } },
                            .load_frame => |frame_addr| .{ .load_frame = .{
                                .index = frame_addr.index,
                                .off = frame_addr.off + off,
                            } },
                            else => unreachable,
                        };
                        const src_limb_reg = if (src_limb_mcv.isRegister())
                            src_limb_mcv.getReg().?
                        else
                            try self.copyToTmpRegister(limb_ty, src_limb_mcv);
                        try self.asmMemoryRegister(
                            mir_limb_tag,
                            dst_limb_mem,
                            registerAlias(src_limb_reg, limb_abi_size),
                        );
                    },
                }
            }
        },
    }
}

fn airArg(self: *CodeGen, inst: Air.Inst.Index) !void {
    const zcu = self.pt.zcu;
    const arg_index = for (self.args, 0..) |arg, arg_index| {
        if (arg != .none) break arg_index;
    } else unreachable;
    const src_mcv = self.args[arg_index];
    self.args = self.args[arg_index + 1 ..];
    const result: MCValue = if (self.mod.strip and self.liveness.isUnused(inst)) .unreach else result: {
        const arg_ty = self.typeOfIndex(inst);
        switch (src_mcv) {
            .register, .register_pair, .load_frame => {
                for (src_mcv.getRegs()) |reg| self.register_manager.getRegAssumeFree(reg, inst);
                break :result src_mcv;
            },
            .indirect => |reg_off| {
                self.register_manager.getRegAssumeFree(reg_off.reg, null);
                const dst_mcv = try self.allocRegOrMem(inst, false);
                try self.genCopy(arg_ty, dst_mcv, src_mcv, .{});
                break :result dst_mcv;
            },
            .indirect_load_frame => |frame_addr| {
                const dst_mcv = try self.allocRegOrMem(inst, false);
                const ptr_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp);
                const ptr_lock = self.register_manager.lockRegAssumeUnused(ptr_reg);
                defer self.register_manager.unlockReg(ptr_lock);
                try self.genSetReg(ptr_reg, .usize, .{ .load_frame = frame_addr }, .{});
                try self.genCopy(arg_ty, dst_mcv, .{ .indirect = .{ .reg = ptr_reg } }, .{});
                break :result dst_mcv;
            },
            .elementwise_args => |regs_frame_addr| {
                try self.spillEflagsIfOccupied();

                const fn_info = zcu.typeToFunc(self.fn_type).?;
                const param_int_regs = abi.getCAbiIntParamRegs(fn_info.cc);
                var prev_reg: Register = undefined;
                for (
                    param_int_regs[param_int_regs.len - regs_frame_addr.regs ..],
                    0..,
                ) |dst_reg, elem_index| {
                    assert(self.register_manager.isRegFree(dst_reg));
                    if (elem_index > 0) {
                        try self.asmRegisterImmediate(.{ ._l, .sh }, dst_reg.to8(), .u(elem_index));
                        try self.asmRegisterRegister(
                            .{ ._, .@"or" },
                            dst_reg.to8(),
                            prev_reg.to8(),
                        );
                    }
                    prev_reg = dst_reg;
                }

                const prev_lock = if (regs_frame_addr.regs > 0)
                    self.register_manager.lockRegAssumeUnused(prev_reg)
                else
                    null;
                defer if (prev_lock) |lock| self.register_manager.unlockReg(lock);

                const dst_mcv = try self.allocRegOrMem(inst, false);
                if (regs_frame_addr.regs > 0) try self.asmMemoryRegister(
                    .{ ._, .mov },
                    try dst_mcv.mem(self, .{ .size = .byte }),
                    prev_reg.to8(),
                );
                try self.genInlineMemset(
                    dst_mcv.address().offset(@intFromBool(regs_frame_addr.regs > 0)),
                    .{ .immediate = 0 },
                    .{ .immediate = arg_ty.abiSize(zcu) - @intFromBool(regs_frame_addr.regs > 0) },
                    .{},
                );

                const index_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp);
                const index_lock = self.register_manager.lockRegAssumeUnused(index_reg);
                defer self.register_manager.unlockReg(index_lock);

                try self.asmRegisterImmediate(
                    .{ ._, .mov },
                    index_reg.to32(),
                    .u(regs_frame_addr.regs),
                );
                const loop: Mir.Inst.Index = @intCast(self.mir_instructions.len);
                try self.asmMemoryImmediate(.{ ._, .cmp }, .{
                    .base = .{ .frame = regs_frame_addr.frame_index },
                    .mod = .{ .rm = .{
                        .size = .byte,
                        .index = index_reg.to64(),
                        .scale = .@"8",
                        .disp = regs_frame_addr.frame_off - @as(u6, regs_frame_addr.regs) * 8,
                    } },
                }, Immediate.u(0));
                const unset = try self.asmJccReloc(.e, undefined);
                try self.asmMemoryRegister(
                    .{ ._s, .bt },
                    try dst_mcv.mem(self, .{ .size = .dword }),
                    index_reg.to32(),
                );
                self.performReloc(unset);
                if (self.hasFeature(.slow_incdec)) {
                    try self.asmRegisterImmediate(.{ ._, .add }, index_reg.to32(), .u(1));
                } else {
                    try self.asmRegister(.{ ._c, .in }, index_reg.to32());
                }
                try self.asmRegisterImmediate(
                    .{ ._, .cmp },
                    index_reg.to32(),
                    .u(arg_ty.vectorLen(zcu)),
                );
                _ = try self.asmJccReloc(.b, loop);

                break :result dst_mcv;
            },
            else => return self.fail("TODO implement arg for {f}", .{src_mcv}),
        }
    };
    return self.finishAir(inst, result, .{ .none, .none, .none });
}

fn genLocalDebugInfo(cg: *CodeGen, air_tag: Air.Inst.Tag, ty: Type, mcv: MCValue) !void {
    assert(!cg.mod.strip);
    _ = switch (air_tag) {
        else => unreachable,
        .arg, .dbg_var_val, .dbg_arg_inline => switch (mcv) {
            .none, .unreach, .dead, .elementwise_args, .reserved_frame, .air_ref => unreachable,
            .immediate => |imm| if (std.math.cast(u32, imm)) |small| try cg.addInst(.{
                .tag = .pseudo,
                .ops = switch (air_tag) {
                    else => unreachable,
                    .arg, .dbg_arg_inline => .pseudo_dbg_arg_i_u,
                    .dbg_var_val => .pseudo_dbg_var_i_u,
                },
                .data = .{ .i = .{ .i = small } },
            }) else try cg.addInst(.{
                .tag = .pseudo,
                .ops = switch (air_tag) {
                    else => unreachable,
                    .arg, .dbg_arg_inline => .pseudo_dbg_arg_i_64,
                    .dbg_var_val => .pseudo_dbg_var_i_64,
                },
                .data = .{ .i64 = imm },
            }),
            .lea_frame => |frame_addr| try cg.addInst(.{
                .tag = .pseudo,
                .ops = switch (air_tag) {
                    else => unreachable,
                    .arg, .dbg_arg_inline => .pseudo_dbg_arg_fa,
                    .dbg_var_val => .pseudo_dbg_var_fa,
                },
                .data = .{ .fa = frame_addr },
            }),
            else => {
                const frame_index = try cg.allocFrameIndex(.initSpill(ty, cg.pt.zcu));
                try cg.genSetMem(.{ .frame = frame_index }, 0, ty, mcv, .{});
                _ = try cg.addInst(.{
                    .tag = .pseudo,
                    .ops = switch (air_tag) {
                        else => unreachable,
                        .arg, .dbg_arg_inline => .pseudo_dbg_arg_m,
                        .dbg_var_val => .pseudo_dbg_var_m,
                    },
                    .data = .{ .x = .{
                        .payload = try cg.addExtra(Mir.Memory.encode(.{
                            .base = .{ .frame = frame_index },
                            .mod = .{ .rm = .{ .size = .qword } },
                        })),
                    } },
                });
            },
        },
        .dbg_var_ptr => switch (mcv) {
            else => unreachable,
            .none, .unreach, .dead, .elementwise_args, .reserved_frame, .air_ref => unreachable,
            .lea_frame => |frame_addr| try cg.addInst(.{
                .tag = .pseudo,
                .ops = .pseudo_dbg_var_m,
                .data = .{ .x = .{
                    .payload = try cg.addExtra(Mir.Memory.encode(.{
                        .base = .{ .frame = frame_addr.index },
                        .mod = .{ .rm = .{
                            .size = .qword,
                            .disp = frame_addr.off,
                        } },
                    })),
                } },
            }),
            .lea_nav => |nav| try cg.addInst(.{
                .tag = .pseudo,
                .ops = .pseudo_dbg_var_m,
                .data = .{ .x = .{
                    .payload = try cg.addExtra(Mir.Memory.encode(.{
                        .base = .{ .nav = nav },
                        .mod = .{ .rm = .{ .size = .qword } },
                    })),
                } },
            }),
            .lea_uav => |uav| try cg.addInst(.{
                .tag = .pseudo,
                .ops = .pseudo_dbg_var_m,
                .data = .{ .x = .{
                    .payload = try cg.addExtra(Mir.Memory.encode(.{
                        .base = .{ .uav = uav },
                        .mod = .{ .rm = .{ .size = .qword } },
                    })),
                } },
            }),
            .lea_lazy_sym => |lazy_sym| try cg.addInst(.{
                .tag = .pseudo,
                .ops = .pseudo_dbg_var_m,
                .data = .{ .x = .{
                    .payload = try cg.addExtra(Mir.Memory.encode(.{
                        .base = .{ .lazy_sym = lazy_sym },
                        .mod = .{ .rm = .{ .size = .qword } },
                    })),
                } },
            }),
            .lea_extern_func => |extern_func| try cg.addInst(.{
                .tag = .pseudo,
                .ops = .pseudo_dbg_var_m,
                .data = .{ .x = .{
                    .payload = try cg.addExtra(Mir.Memory.encode(.{
                        .base = .{ .extern_func = extern_func },
                        .mod = .{ .rm = .{ .size = .qword } },
                    })),
                } },
            }),
        },
    };
}

fn airCall(self: *CodeGen, inst: Air.Inst.Index, modifier: std.builtin.CallModifier, opts: CopyOptions) !void {
    if (modifier == .always_tail) return self.fail("TODO implement tail calls for x86_64", .{});

    const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
    const extra = self.air.extraData(Air.Call, pl_op.payload);
    const arg_refs: []const Air.Inst.Ref =
        @ptrCast(self.air.extra.items[extra.end..][0..extra.data.args_len]);

    const ExpectedContents = extern struct {
        tys: [32][@sizeOf(Type)]u8 align(@alignOf(Type)),
        vals: [32][@sizeOf(MCValue)]u8 align(@alignOf(MCValue)),
    };
    var stack align(@max(@alignOf(ExpectedContents), @alignOf(std.heap.StackFallbackAllocator(0)))) =
        std.heap.stackFallback(@sizeOf(ExpectedContents), self.gpa);
    const allocator = stack.get();

    const arg_tys = try allocator.alloc(Type, arg_refs.len);
    defer allocator.free(arg_tys);
    for (arg_tys, arg_refs) |*arg_ty, arg_ref| arg_ty.* = self.typeOf(arg_ref);

    const arg_vals = try allocator.alloc(MCValue, arg_refs.len);
    defer allocator.free(arg_vals);
    for (arg_vals, arg_refs) |*arg_val, arg_ref| arg_val.* = .{ .air_ref = arg_ref };

    const ret = try self.genCall(.{ .air = pl_op.operand }, arg_tys, arg_vals, opts);

    var bt = self.liveness.iterateBigTomb(inst);
    try self.feed(&bt, pl_op.operand);
    for (arg_refs) |arg_ref| try self.feed(&bt, arg_ref);

    const result = if (self.liveness.isUnused(inst)) .unreach else ret;
    return self.finishAirResult(inst, result);
}

fn genCall(self: *CodeGen, info: union(enum) {
    air: Air.Inst.Ref,
    extern_func: struct {
        return_type: InternPool.Index,
        param_types: []const InternPool.Index,
        sym: []const u8,
    },
}, arg_types: []const Type, args: []const MCValue, opts: CopyOptions) !MCValue {
    const pt = self.pt;
    const zcu = pt.zcu;
    const ip = &zcu.intern_pool;

    const fn_ty = switch (info) {
        .air => |callee| fn_info: {
            const callee_ty = self.typeOf(callee);
            break :fn_info switch (callee_ty.zigTypeTag(zcu)) {
                .@"fn" => callee_ty,
                .pointer => callee_ty.childType(zcu),
                else => unreachable,
            };
        },
        .extern_func => |extern_func| try pt.funcType(.{
            .param_types = extern_func.param_types,
            .return_type = extern_func.return_type,
            .cc = self.target.cCallingConvention().?,
        }),
    };
    const fn_info = zcu.typeToFunc(fn_ty).?;

    const ExpectedContents = extern struct {
        var_args: [32][@sizeOf(Type)]u8 align(@alignOf(Type)),
        frame_indices: [32]FrameIndex,
        reg_locks: [32][@sizeOf(?RegisterLock)]u8 align(@alignOf(?RegisterLock)),
    };
    var stack align(@max(@alignOf(ExpectedContents), @alignOf(std.heap.StackFallbackAllocator(0)))) =
        std.heap.stackFallback(@sizeOf(ExpectedContents), self.gpa);
    const allocator = stack.get();

    const var_args = try allocator.alloc(Type, args.len - fn_info.param_types.len);
    defer allocator.free(var_args);
    for (var_args, arg_types[fn_info.param_types.len..]) |*var_arg, arg_ty| var_arg.* = arg_ty;

    const frame_indices = try allocator.alloc(FrameIndex, args.len);
    defer allocator.free(frame_indices);

    var reg_locks: std.array_list.Managed(?RegisterLock) = .init(allocator);
    defer reg_locks.deinit();
    try reg_locks.ensureTotalCapacity(16);
    defer for (reg_locks.items) |reg_lock| if (reg_lock) |lock| self.register_manager.unlockReg(lock);

    var call_info = try self.resolveCallingConventionValues(fn_info, var_args, .call_frame);
    defer call_info.deinit(self);

    // We need a properly aligned and sized call frame to be able to call this function.
    {
        const needed_call_frame: FrameAlloc = .init(.{
            .size = call_info.stack_byte_count,
            .alignment = call_info.stack_align,
        });
        const frame_allocs_slice = self.frame_allocs.slice();
        const stack_frame_size =
            &frame_allocs_slice.items(.abi_size)[@intFromEnum(FrameIndex.call_frame)];
        stack_frame_size.* = @max(stack_frame_size.*, needed_call_frame.abi_size);
        const stack_frame_align =
            &frame_allocs_slice.items(.abi_align)[@intFromEnum(FrameIndex.call_frame)];
        stack_frame_align.* = stack_frame_align.max(needed_call_frame.abi_align);
    }

    try self.spillEflagsIfOccupied();
    try self.spillCallerPreservedRegs(fn_info.cc, call_info.err_ret_trace_reg);

    // set stack arguments first because this can clobber registers
    // also clobber spill arguments as we go
    switch (call_info.return_value.long) {
        .none, .unreach => {},
        .indirect => |reg_off| try self.register_manager.getReg(reg_off.reg, null),
        else => unreachable,
    }
    for (call_info.args, arg_types, args, frame_indices) |dst_arg, arg_ty, src_arg, *frame_index|
        switch (dst_arg) {
            .none => {},
            .register => |reg| {
                try self.register_manager.getReg(reg, null);
                try reg_locks.append(self.register_manager.lockReg(reg));
            },
            .register_pair => |regs| {
                for (regs) |reg| try self.register_manager.getReg(reg, null);
                try reg_locks.appendSlice(&self.register_manager.lockRegs(2, regs));
            },
            .indirect => |reg_off| {
                frame_index.* = try self.allocFrameIndex(.initType(arg_ty, zcu));
                try self.genSetMem(.{ .frame = frame_index.* }, 0, arg_ty, src_arg, opts);
                try self.register_manager.getReg(reg_off.reg, null);
                try reg_locks.append(self.register_manager.lockReg(reg_off.reg));
            },
            .load_frame => {
                try self.genCopy(arg_ty, dst_arg, src_arg, opts);
                try self.freeValue(src_arg, .{});
            },
            .elementwise_args => |regs_frame_addr| {
                const index_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp);
                const index_lock = self.register_manager.lockRegAssumeUnused(index_reg);
                defer self.register_manager.unlockReg(index_lock);

                const src_mem: Memory = if (src_arg.isBase()) try src_arg.mem(self, .{ .size = .dword }) else .{
                    .base = .{ .reg = try self.copyToTmpRegister(.usize, switch (src_arg) {
                        else => src_arg,
                        .air_ref => |src_ref| try self.resolveInst(src_ref),
                    }.address()) },
                    .mod = .{ .rm = .{ .size = .dword } },
                };
                const src_lock = switch (src_mem.base) {
                    .reg => |src_reg| self.register_manager.lockReg(src_reg),
                    else => null,
                };
                defer if (src_lock) |lock| self.register_manager.unlockReg(lock);

                try self.asmRegisterImmediate(
                    .{ ._, .mov },
                    index_reg.to32(),
                    .u(regs_frame_addr.regs),
                );
                const loop: Mir.Inst.Index = @intCast(self.mir_instructions.len);
                try self.asmMemoryRegister(.{ ._, .bt }, src_mem, index_reg.to32());
                try self.asmSetccMemory(.c, .{
                    .base = .{ .frame = regs_frame_addr.frame_index },
                    .mod = .{ .rm = .{
                        .size = .byte,
                        .index = index_reg.to64(),
                        .scale = .@"8",
                        .disp = regs_frame_addr.frame_off - @as(u6, regs_frame_addr.regs) * 8,
                    } },
                });
                if (self.hasFeature(.slow_incdec)) {
                    try self.asmRegisterImmediate(.{ ._, .add }, index_reg.to32(), .u(1));
                } else {
                    try self.asmRegister(.{ ._c, .in }, index_reg.to32());
                }
                try self.asmRegisterImmediate(
                    .{ ._, .cmp },
                    index_reg.to32(),
                    .u(arg_ty.vectorLen(zcu)),
                );
                _ = try self.asmJccReloc(.b, loop);

                const param_int_regs = abi.getCAbiIntParamRegs(fn_info.cc);
                for (param_int_regs[param_int_regs.len - regs_frame_addr.regs ..]) |dst_reg| {
                    try self.register_manager.getReg(dst_reg, null);
                    try reg_locks.append(self.register_manager.lockReg(dst_reg));
                }
            },
            else => unreachable,
        };

    if (call_info.err_ret_trace_reg != .none) {
        if (self.inst_tracking.getPtr(err_ret_trace_index)) |err_ret_trace| {
            if (switch (err_ret_trace.short) {
                .register => |reg| call_info.err_ret_trace_reg != reg,
                else => true,
            }) {
                try self.register_manager.getReg(call_info.err_ret_trace_reg, err_ret_trace_index);
                try reg_locks.append(self.register_manager.lockReg(call_info.err_ret_trace_reg));

                try self.genSetReg(call_info.err_ret_trace_reg, .usize, err_ret_trace.short, .{});
                err_ret_trace.trackMaterialize(err_ret_trace_index, .{
                    .long = err_ret_trace.long,
                    .short = .{ .register = call_info.err_ret_trace_reg },
                });
            }
        }
    }

    // now we are free to set register arguments
    switch (call_info.return_value.long) {
        .none, .unreach => {},
        .indirect => |reg_off| {
            const ret_ty: Type = .fromInterned(fn_info.return_type);
            const frame_index = try self.allocFrameIndex(.initSpill(ret_ty, zcu));
            try self.genSetReg(reg_off.reg, .usize, .{
                .lea_frame = .{ .index = frame_index, .off = -reg_off.off },
            }, .{});
            call_info.return_value.short = .{ .load_frame = .{ .index = frame_index } };
            try reg_locks.append(self.register_manager.lockReg(reg_off.reg));
        },
        else => unreachable,
    }

    for (call_info.args, arg_types, args, frame_indices) |dst_arg, arg_ty, src_arg, frame_index|
        switch (dst_arg) {
            .none, .load_frame => {},
            .register => |dst_reg| switch (fn_info.cc) {
                else => try self.genSetReg(registerAlias(
                    dst_reg,
                    @intCast(arg_ty.abiSize(zcu)),
                ), arg_ty, src_arg, opts),
                .x86_64_sysv, .x86_64_win => {
                    const promoted_ty = self.promoteInt(arg_ty);
                    const promoted_abi_size: u32 = @intCast(promoted_ty.abiSize(zcu));
                    const dst_alias = registerAlias(dst_reg, promoted_abi_size);
                    try self.genSetReg(dst_alias, promoted_ty, src_arg, opts);
                    if (promoted_ty.toIntern() != arg_ty.toIntern())
                        try self.truncateRegister(arg_ty, dst_alias);
                },
            },
            .register_pair => try self.genCopy(arg_ty, dst_arg, src_arg, opts),
            .indirect => |reg_off| try self.genSetReg(reg_off.reg, .usize, .{
                .lea_frame = .{ .index = frame_index, .off = -reg_off.off },
            }, .{}),
            .elementwise_args => |regs_frame_addr| {
                const src_mem: Memory = if (src_arg.isBase()) try src_arg.mem(self, .{ .size = .dword }) else .{
                    .base = .{ .reg = try self.copyToTmpRegister(
                        .usize,
                        switch (src_arg) {
                            else => src_arg,
                            .air_ref => |src_ref| try self.resolveInst(src_ref),
                        }.address(),
                    ) },
                    .mod = .{ .rm = .{ .size = .dword } },
                };
                const src_lock = switch (src_mem.base) {
                    .reg => |src_reg| self.register_manager.lockReg(src_reg),
                    else => null,
                };
                defer if (src_lock) |lock| self.register_manager.unlockReg(lock);

                const param_int_regs = abi.getCAbiIntParamRegs(fn_info.cc);
                for (
                    param_int_regs[param_int_regs.len - regs_frame_addr.regs ..],
                    0..,
                ) |dst_reg, elem_index| {
                    try self.asmRegisterRegister(.{ ._, .xor }, dst_reg.to32(), dst_reg.to32());
                    try self.asmMemoryImmediate(.{ ._, .bt }, src_mem, .u(elem_index));
                    try self.asmSetccRegister(.c, dst_reg.to8());
                }
            },
            else => unreachable,
        };

    if (fn_info.is_var_args) try self.asmRegisterImmediate(.{ ._, .mov }, .al, .u(call_info.fp_count));

    // Due to incremental compilation, how function calls are generated depends
    // on linking.
    switch (info) {
        .air => |callee| if (try self.air.value(callee, pt)) |func_value| {
            const func_key = ip.indexToKey(func_value.ip_index);
            switch (switch (func_key) {
                else => func_key,
                .ptr => |ptr| if (ptr.byte_offset == 0) switch (ptr.base_addr) {
                    .nav => |nav| ip.indexToKey(zcu.navValue(nav).toIntern()),
                    else => func_key,
                } else func_key,
            }) {
                else => unreachable,
                .func => |func| try self.asmImmediate(.{ ._, .call }, .{ .nav = .{ .index = func.owner_nav } }),
                .@"extern" => |@"extern"| try self.asmImmediate(.{ ._, .call }, .{ .nav = .{ .index = @"extern".owner_nav } }),
            }
        } else {
            assert(self.typeOf(callee).zigTypeTag(zcu) == .pointer);
            const scratch_reg = abi.getCAbiLinkerScratchReg(fn_info.cc);
            try self.genSetReg(scratch_reg, .usize, .{ .air_ref = callee }, .{});
            try self.asmRegister(.{ ._, .call }, scratch_reg);
        },
        .extern_func => |extern_func| try self.asmImmediate(.{ ._, .call }, .{ .extern_func = try self.addString(extern_func.sym) }),
    }
    return call_info.return_value.short;
}

fn airRet(self: *CodeGen, inst: Air.Inst.Index, safety: bool) !void {
    const pt = self.pt;
    const zcu = pt.zcu;
    const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;

    const ret_ty = self.fn_type.fnReturnType(zcu);
    switch (self.ret_mcv.short) {
        .none => {},
        .register => |reg| {
            const reg_lock = self.register_manager.lockRegAssumeUnused(reg);
            defer self.register_manager.unlockReg(reg_lock);
            try self.genCopy(ret_ty, self.ret_mcv.short, .{ .air_ref = un_op }, .{ .safety = safety });
        },
        inline .register_pair, .register_triple, .register_quadruple => |regs| {
            const reg_locks = self.register_manager.lockRegsAssumeUnused(regs.len, regs);
            defer for (reg_locks) |reg_lock| self.register_manager.unlockReg(reg_lock);
            try self.genCopy(ret_ty, self.ret_mcv.short, .{ .air_ref = un_op }, .{ .safety = safety });
        },
        .indirect => |reg_off| {
            try self.register_manager.getReg(reg_off.reg, null);
            const lock = self.register_manager.lockRegAssumeUnused(reg_off.reg);
            defer self.register_manager.unlockReg(lock);

            try self.genSetReg(reg_off.reg, .usize, self.ret_mcv.long, .{});
            try self.genSetMem(
                .{ .reg = reg_off.reg },
                reg_off.off,
                ret_ty,
                .{ .air_ref = un_op },
                .{ .safety = safety },
            );
        },
        else => unreachable,
    }
    self.ret_mcv.liveOut(self, inst);

    if (self.err_ret_trace_reg != .none) {
        if (self.inst_tracking.getPtr(err_ret_trace_index)) |err_ret_trace| {
            if (switch (err_ret_trace.short) {
                .register => |reg| self.err_ret_trace_reg != reg,
                else => true,
            }) try self.genSetReg(self.err_ret_trace_reg, .usize, err_ret_trace.short, .{});
            err_ret_trace.liveOut(self, err_ret_trace_index);
        }
    }

    try self.finishAir(inst, .unreach, .{ un_op, .none, .none });

    // TODO optimization opportunity: figure out when we can emit this as a 2 byte instruction
    // which is available if the jump is 127 bytes or less forward.
    const jmp_reloc = try self.asmJmpReloc(undefined);
    try self.epilogue_relocs.append(self.gpa, jmp_reloc);
}

fn airRetLoad(self: *CodeGen, inst: Air.Inst.Index) !void {
    const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
    const ptr = try self.resolveInst(un_op);

    const ptr_ty = self.typeOf(un_op);
    switch (self.ret_mcv.short) {
        .none => {},
        .register, .register_pair => try self.load(self.ret_mcv.short, ptr_ty, ptr),
        .indirect => |reg_off| try self.genSetReg(reg_off.reg, ptr_ty, ptr, .{}),
        else => unreachable,
    }
    self.ret_mcv.liveOut(self, inst);

    if (self.err_ret_trace_reg != .none) {
        if (self.inst_tracking.getPtr(err_ret_trace_index)) |err_ret_trace| {
            if (switch (err_ret_trace.short) {
                .register => |reg| self.err_ret_trace_reg != reg,
                else => true,
            }) try self.genSetReg(self.err_ret_trace_reg, .usize, err_ret_trace.short, .{});
            err_ret_trace.liveOut(self, err_ret_trace_index);
        }
    }

    try self.finishAir(inst, .unreach, .{ un_op, .none, .none });

    // TODO optimization opportunity: figure out when we can emit this as a 2 byte instruction
    // which is available if the jump is 127 bytes or less forward.
    const jmp_reloc = try self.asmJmpReloc(undefined);
    try self.epilogue_relocs.append(self.gpa, jmp_reloc);
}

fn airTry(self: *CodeGen, inst: Air.Inst.Index) !void {
    const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
    const extra = self.air.extraData(Air.Try, pl_op.payload);
    const body: []const Air.Inst.Index = @ptrCast(self.air.extra.items[extra.end..][0..extra.data.body_len]);
    const operand_ty = self.typeOf(pl_op.operand);
    const result = try self.genTry(inst, pl_op.operand, body, operand_ty, false);
    return self.finishAir(inst, result, .{ .none, .none, .none });
}

fn airTryPtr(self: *CodeGen, inst: Air.Inst.Index) !void {
    const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
    const extra = self.air.extraData(Air.TryPtr, ty_pl.payload);
    const body: []const Air.Inst.Index = @ptrCast(self.air.extra.items[extra.end..][0..extra.data.body_len]);
    const operand_ty = self.typeOf(extra.data.ptr);
    const result = try self.genTry(inst, extra.data.ptr, body, operand_ty, true);
    return self.finishAir(inst, result, .{ .none, .none, .none });
}

fn genTry(
    self: *CodeGen,
    inst: Air.Inst.Index,
    operand: Air.Inst.Ref,
    body: []const Air.Inst.Index,
    operand_ty: Type,
    operand_is_ptr: bool,
) !MCValue {
    const liveness_cond_br = self.liveness.getCondBr(inst);

    const operand_mcv = try self.resolveInst(operand);
    const is_err_mcv = if (operand_is_ptr)
        try self.isErrPtr(null, operand_ty, operand_mcv)
    else
        try self.isErr(null, operand_ty, operand_mcv);

    const reloc = try self.genCondBrMir(.anyerror, is_err_mcv);

    if (self.liveness.operandDies(inst, 0)) {
        if (operand.toIndex()) |operand_inst| try self.processDeath(operand_inst, .{});
    }

    const state = try self.saveState();

    for (liveness_cond_br.else_deaths) |death| try self.processDeath(death, .{});
    try self.genBodyBlock(body);
    try self.restoreState(state, &.{}, .{
        .emit_instructions = false,
        .update_tracking = true,
        .resurrect = true,
        .close_scope = true,
    });

    self.performReloc(reloc);

    for (liveness_cond_br.then_deaths) |death| try self.processDeath(death, .{});

    const result = if (self.liveness.isUnused(inst))
        .unreach
    else if (operand_is_ptr)
        try self.genUnwrapErrUnionPayloadPtrMir(inst, operand_ty, operand_mcv)
    else
        try self.genUnwrapErrUnionPayloadMir(inst, operand_ty, operand_mcv);
    return result;
}

fn genCondBrMir(self: *CodeGen, ty: Type, mcv: MCValue) !Mir.Inst.Index {
    const pt = self.pt;
    const abi_size = ty.abiSize(pt.zcu);
    switch (mcv) {
        .eflags => |cc| {
            // Here we map the opposites since the jump is to the false branch.
            return self.asmJccReloc(cc.negate(), undefined);
        },
        .register => |reg| {
            try self.spillEflagsIfOccupied();
            try self.asmRegisterImmediate(.{ ._, .@"test" }, reg.to8(), .u(1));
            return self.asmJccReloc(.z, undefined);
        },
        .immediate,
        .load_frame,
        => {
            try self.spillEflagsIfOccupied();
            if (abi_size <= 8) {
                const reg = try self.copyToTmpRegister(ty, mcv);
                return self.genCondBrMir(ty, .{ .register = reg });
            }
            return self.fail("TODO implement condbr when condition is {f} with abi larger than 8 bytes", .{mcv});
        },
        else => return self.fail("TODO implement condbr when condition is {s}", .{@tagName(mcv)}),
    }
}

fn airCondBr(self: *CodeGen, inst: Air.Inst.Index) !void {
    const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
    const cond = try self.resolveInst(pl_op.operand);
    const cond_ty = self.typeOf(pl_op.operand);
    const extra = self.air.extraData(Air.CondBr, pl_op.payload);
    const then_body: []const Air.Inst.Index =
        @ptrCast(self.air.extra.items[extra.end..][0..extra.data.then_body_len]);
    const else_body: []const Air.Inst.Index =
        @ptrCast(self.air.extra.items[extra.end + then_body.len ..][0..extra.data.else_body_len]);
    const liveness_cond_br = self.liveness.getCondBr(inst);

    // If the condition dies here in this condbr instruction, process
    // that death now instead of later as this has an effect on
    // whether it needs to be spilled in the branches
    if (self.liveness.operandDies(inst, 0)) {
        if (pl_op.operand.toIndex()) |op_inst| try self.processDeath(op_inst, .{});
    }

    const state = try self.saveState();
    const reloc = try self.genCondBrMir(cond_ty, cond);

    for (liveness_cond_br.then_deaths) |death| try self.processDeath(death, .{});
    try self.genBodyBlock(then_body);
    try self.restoreState(state, &.{}, .{
        .emit_instructions = false,
        .update_tracking = true,
        .resurrect = true,
        .close_scope = true,
    });

    self.performReloc(reloc);

    for (liveness_cond_br.else_deaths) |death| try self.processDeath(death, .{});
    try self.genBodyBlock(else_body);
    try self.restoreState(state, &.{}, .{
        .emit_instructions = false,
        .update_tracking = true,
        .resurrect = true,
        .close_scope = true,
    });

    // We already took care of pl_op.operand earlier, so there's nothing left to do.
}

fn isErr(self: *CodeGen, maybe_inst: ?Air.Inst.Index, eu_ty: Type, eu_mcv: MCValue) !MCValue {
    const pt = self.pt;
    const zcu = pt.zcu;
    const err_ty = eu_ty.errorUnionSet(zcu);
    if (err_ty.errorSetIsEmpty(zcu)) return MCValue{ .immediate = 0 }; // always false

    try self.spillEflagsIfOccupied();

    const err_off: u31 = @intCast(codegen.errUnionErrorOffset(eu_ty.errorUnionPayload(zcu), zcu));
    switch (eu_mcv) {
        .register => |reg| {
            const eu_lock = self.register_manager.lockReg(reg);
            defer if (eu_lock) |lock| self.register_manager.unlockReg(lock);

            const tmp_reg = try self.copyToTmpRegister(eu_ty, eu_mcv);
            if (err_off > 0) {
                try self.genShiftBinOpMir(
                    .{ ._r, .sh },
                    eu_ty,
                    .{ .register = tmp_reg },
                    .u8,
                    .{ .immediate = @as(u6, @intCast(err_off * 8)) },
                );
            } else {
                try self.truncateRegister(.anyerror, tmp_reg);
            }
            try self.genBinOpMir(.{ ._, .cmp }, .anyerror, .{ .register = tmp_reg }, .{ .immediate = 0 });
        },
        .load_frame => |frame_addr| try self.genBinOpMir(
            .{ ._, .cmp },
            .anyerror,
            .{ .load_frame = .{
                .index = frame_addr.index,
                .off = frame_addr.off + err_off,
            } },
            .{ .immediate = 0 },
        ),
        else => return self.fail("TODO implement isErr for {f}", .{eu_mcv}),
    }

    if (maybe_inst) |inst| self.eflags_inst = inst;
    return MCValue{ .eflags = .a };
}

fn isErrPtr(self: *CodeGen, maybe_inst: ?Air.Inst.Index, ptr_ty: Type, ptr_mcv: MCValue) !MCValue {
    const pt = self.pt;
    const zcu = pt.zcu;
    const eu_ty = ptr_ty.childType(zcu);
    const err_ty = eu_ty.errorUnionSet(zcu);
    if (err_ty.errorSetIsEmpty(zcu)) return MCValue{ .immediate = 0 }; // always false

    try self.spillEflagsIfOccupied();

    const ptr_reg = switch (ptr_mcv) {
        .register => |reg| reg,
        else => try self.copyToTmpRegister(ptr_ty, ptr_mcv),
    };
    const ptr_lock = self.register_manager.lockReg(ptr_reg);
    defer if (ptr_lock) |lock| self.register_manager.unlockReg(lock);

    const err_off: u31 = @intCast(codegen.errUnionErrorOffset(eu_ty.errorUnionPayload(zcu), zcu));
    try self.asmMemoryImmediate(
        .{ ._, .cmp },
        .{
            .base = .{ .reg = ptr_reg },
            .mod = .{ .rm = .{
                .size = self.memSize(.anyerror),
                .disp = err_off,
            } },
        },
        .u(0),
    );

    if (maybe_inst) |inst| self.eflags_inst = inst;
    return MCValue{ .eflags = .a };
}

fn lowerBlock(self: *CodeGen, inst: Air.Inst.Index, body: []const Air.Inst.Index) !void {
    // A block is a setup to be able to jump to the end.
    const inst_tracking_i = self.inst_tracking.count();
    self.inst_tracking.putAssumeCapacityNoClobber(inst, .init(.unreach));

    try self.blocks.putNoClobber(self.gpa, inst, .{ .state = self.initRetroactiveState() });
    const liveness = self.liveness.getBlock(inst);

    try self.genBody(body);

    var block_data = self.blocks.fetchRemove(inst).?;
    defer block_data.value.deinit(self.gpa);
    if (block_data.value.relocs.items.len > 0) {
        var last_inst: Mir.Inst.Index = @intCast(self.mir_instructions.len - 1);
        while (block_data.value.relocs.getLastOrNull() == last_inst) {
            block_data.value.relocs.items.len -= 1;
            self.mir_instructions.set(last_inst, .{
                .tag = .pseudo,
                .ops = .pseudo_dead_none,
                .data = undefined,
            });
            last_inst -= 1;
        }
        for (block_data.value.relocs.items) |block_reloc| self.performReloc(block_reloc);
        try self.restoreState(block_data.value.state, liveness.deaths, .{
            .emit_instructions = false,
            .update_tracking = true,
            .resurrect = true,
            .close_scope = true,
        });
    }

    if (std.debug.runtime_safety) assert(self.inst_tracking.getIndex(inst).? == inst_tracking_i);
    const tracking = &self.inst_tracking.values()[inst_tracking_i];
    if (self.liveness.isUnused(inst)) try tracking.die(self, inst, .{});
    self.getValueIfFree(tracking.short, inst);
}

fn lowerSwitchBr(
    cg: *CodeGen,
    inst: Air.Inst.Index,
    switch_br: Air.UnwrappedSwitch,
    condition: MCValue,
    condition_dies: bool,
    is_loop: bool,
) !void {
    const zcu = cg.pt.zcu;
    const condition_ty = cg.typeOf(switch_br.operand);
    const unsigned_condition_ty = try cg.pt.intType(.unsigned, cg.intInfo(condition_ty).?.bits);

    const ExpectedContents = extern struct {
        liveness_deaths: [1 << 8 | 1]Air.Inst.Index,
        bigint_limbs: [std.math.big.int.calcTwosCompLimbCount(1 << 10)]std.math.big.Limb,
        relocs: [1 << 6]Mir.Inst.Index,
    };
    var stack align(@max(@alignOf(ExpectedContents), @alignOf(std.heap.StackFallbackAllocator(0)))) =
        std.heap.stackFallback(@sizeOf(ExpectedContents), cg.gpa);
    const allocator = stack.get();

    const state = try cg.saveState();

    const liveness = try cg.liveness.getSwitchBr(allocator, inst, switch_br.cases_len + 1);
    defer allocator.free(liveness.deaths);

    if (!cg.mod.pic and cg.target.ofmt == .elf) table: {
        var prong_items: u32 = 0;
        var min: ?Value = null;
        var max: ?Value = null;
        {
            var cases_it = switch_br.iterateCases();
            while (cases_it.next()) |case| {
                prong_items += @intCast(case.items.len + case.ranges.len);
                for (case.items) |item| {
                    const val = Value.fromInterned(item.toInterned().?);
                    if (min == null or val.compareHetero(.lt, min.?, zcu)) min = val;
                    if (max == null or val.compareHetero(.gt, max.?, zcu)) max = val;
                }
                for (case.ranges) |range| {
                    const low = Value.fromInterned(range[0].toInterned().?);
                    if (min == null or low.compareHetero(.lt, min.?, zcu)) min = low;
                    const high = Value.fromInterned(range[1].toInterned().?);
                    if (max == null or high.compareHetero(.gt, max.?, zcu)) max = high;
                }
            }
        }
        // This condition also triggers for switches with no non-else prongs and switches on bool.
        if (prong_items < 1 << 2 or prong_items > 1 << 8) break :table;

        var min_space: Value.BigIntSpace = undefined;
        const min_bigint = min.?.toBigInt(&min_space, zcu);
        var max_space: Value.BigIntSpace = undefined;
        const max_bigint = max.?.toBigInt(&max_space, zcu);
        const limbs = try allocator.alloc(
            std.math.big.Limb,
            @max(min_bigint.limbs.len, max_bigint.limbs.len) + 1,
        );
        defer allocator.free(limbs);
        const table_len = table_len: {
            var table_len_bigint: std.math.big.int.Mutable = .{ .limbs = limbs, .positive = undefined, .len = undefined };
            table_len_bigint.sub(max_bigint, min_bigint);
            assert(table_len_bigint.positive); // min <= max
            break :table_len @as(u11, table_len_bigint.toConst().toInt(u10) catch break :table) + 1; // no more than a 1024 entry table
        };
        assert(prong_items <= table_len); // each prong item introduces at least one unique integer to the range
        if (prong_items < table_len >> 2) break :table; // no more than 75% waste

        const condition_index = if (condition_dies and condition.isModifiable()) condition else condition_index: {
            const condition_index = try cg.allocTempRegOrMem(condition_ty, true);
            try cg.genCopy(condition_ty, condition_index, condition, .{});
            break :condition_index condition_index;
        };
        try cg.spillEflagsIfOccupied();
        if (min.?.orderAgainstZero(zcu).compare(.neq)) try cg.genBinOpMir(
            .{ ._, .sub },
            condition_ty,
            condition_index,
            .{ .air_ref = Air.internedToRef(min.?.toIntern()) },
        );
        const else_reloc = if (switch_br.else_body_len > 0) else_reloc: {
            var cond_temp = try cg.tempInit(unsigned_condition_ty, condition_index);
            var table_max_temp = try cg.tempFromValue(try cg.pt.intValue(unsigned_condition_ty, table_len - 1));
            const cc_temp = cond_temp.cmpInts(.gt, &table_max_temp, cg) catch |err| switch (err) {
                error.SelectFailed => unreachable,
                else => |e| return e,
            };
            try cond_temp.die(cg);
            try table_max_temp.die(cg);
            const else_reloc = try cg.asmJccReloc(cc_temp.tracking(cg).short.eflags, undefined);
            try cc_temp.die(cg);
            break :else_reloc else_reloc;
        } else undefined;
        const table_start: u31 = @intCast(cg.mir_table.items.len);
        {
            const condition_index_reg = condition_index_reg: {
                if (condition_index.isRegister()) {
                    const condition_index_reg = condition_index.getReg().?;
                    if (condition_index_reg.isClass(.general_purpose)) break :condition_index_reg condition_index_reg;
                }
                break :condition_index_reg try cg.copyToTmpRegister(.usize, condition_index);
            };
            const condition_index_lock = cg.register_manager.lockReg(condition_index_reg);
            defer if (condition_index_lock) |lock| cg.register_manager.unlockReg(lock);
            try cg.truncateRegister(condition_ty, condition_index_reg);
            const ptr_size = @divExact(cg.target.ptrBitWidth(), 8);
            try cg.asmMemory(.{ ._mp, .j }, .{
                .base = .table,
                .mod = .{ .rm = .{
                    .size = .ptr,
                    .index = condition_index_reg.toSize(.ptr, cg.target),
                    .scale = .fromFactor(@intCast(ptr_size)),
                    .disp = table_start * ptr_size,
                } },
            });
        }
        const else_reloc_marker: u32 = 0;
        assert(cg.mir_instructions.len > else_reloc_marker);
        try cg.mir_table.appendNTimes(cg.gpa, else_reloc_marker, table_len);
        if (is_loop) try cg.loop_switches.putNoClobber(cg.gpa, inst, .{
            .start = table_start,
            .len = table_len,
            .min = min.?,
            .else_relocs = if (switch_br.else_body_len > 0) .{ .forward = .empty } else .@"unreachable",
        });
        defer if (is_loop) {
            var loop_switch_data = cg.loop_switches.fetchRemove(inst).?.value;
            switch (loop_switch_data.else_relocs) {
                .@"unreachable", .backward => {},
                .forward => |*else_relocs| else_relocs.deinit(cg.gpa),
            }
        };
        var cases_it = switch_br.iterateCases();
        while (cases_it.next()) |case| {
            {
                const table = cg.mir_table.items[table_start..][0..table_len];
                for (case.items) |item| {
                    const val = Value.fromInterned(item.toInterned().?);
                    var val_space: Value.BigIntSpace = undefined;
                    const val_bigint = val.toBigInt(&val_space, zcu);
                    var index_bigint: std.math.big.int.Mutable = .{ .limbs = limbs, .positive = undefined, .len = undefined };
                    index_bigint.sub(val_bigint, min_bigint);
                    table[index_bigint.toConst().toInt(u10) catch unreachable] = @intCast(cg.mir_instructions.len);
                }
                for (case.ranges) |range| {
                    var low_space: Value.BigIntSpace = undefined;
                    const low_bigint = Value.fromInterned(range[0].toInterned().?).toBigInt(&low_space, zcu);
                    var high_space: Value.BigIntSpace = undefined;
                    const high_bigint = Value.fromInterned(range[1].toInterned().?).toBigInt(&high_space, zcu);
                    var index_bigint: std.math.big.int.Mutable = .{ .limbs = limbs, .positive = undefined, .len = undefined };
                    index_bigint.sub(low_bigint, min_bigint);
                    const start = index_bigint.toConst().toInt(u10) catch unreachable;
                    index_bigint.sub(high_bigint, min_bigint);
                    const end = @as(u11, index_bigint.toConst().toInt(u10) catch unreachable) + 1;
                    @memset(table[start..end], @intCast(cg.mir_instructions.len));
                }
            }

            for (liveness.deaths[case.idx]) |operand| try cg.processDeath(operand, .{});

            try cg.genBodyBlock(case.body);
            try cg.restoreState(state, &.{}, .{
                .emit_instructions = false,
                .update_tracking = true,
                .resurrect = true,
                .close_scope = true,
            });
        }
        if (switch_br.else_body_len > 0) {
            const else_body = cases_it.elseBody();

            const else_deaths = liveness.deaths.len - 1;
            for (liveness.deaths[else_deaths]) |operand| try cg.processDeath(operand, .{});

            cg.performReloc(else_reloc);
            if (is_loop) {
                const loop_switch_data = cg.loop_switches.getPtr(inst).?;
                for (loop_switch_data.else_relocs.forward.items) |reloc| cg.performReloc(reloc);
                loop_switch_data.else_relocs.forward.deinit(cg.gpa);
                loop_switch_data.else_relocs = .{ .backward = @intCast(cg.mir_instructions.len) };
            }
            for (cg.mir_table.items[table_start..][0..table_len]) |*entry| if (entry.* == else_reloc_marker) {
                entry.* = @intCast(cg.mir_instructions.len);
            };

            try cg.genBodyBlock(else_body);
            try cg.restoreState(state, &.{}, .{
                .emit_instructions = false,
                .update_tracking = true,
                .resurrect = true,
                .close_scope = true,
            });
        }
        return;
    }

    var cases_it = switch_br.iterateCases();
    while (cases_it.next()) |case| {
        const relocs = try allocator.alloc(Mir.Inst.Index, case.items.len + case.ranges.len);
        defer allocator.free(relocs);

        try cg.spillEflagsIfOccupied();
        for (case.items, relocs[0..case.items.len]) |item, *reloc| {
            const item_mcv = try cg.resolveInst(item);
            const cc: Condition = switch (condition) {
                .eflags => |cc| switch (item_mcv.immediate) {
                    0 => cc.negate(),
                    1 => cc,
                    else => unreachable,
                },
                else => cc: {
                    var cond_temp = try cg.tempInit(condition_ty, condition);
                    var item_temp = try cg.tempInit(condition_ty, item_mcv);
                    const cc_temp = cond_temp.cmpInts(.eq, &item_temp, cg) catch |err| switch (err) {
                        error.SelectFailed => unreachable,
                        else => |e| return e,
                    };
                    try item_temp.die(cg);
                    const cc = cc_temp.tracking(cg).short.eflags;
                    try cc_temp.die(cg);
                    try cond_temp.die(cg);
                    try cg.resetTemps(@enumFromInt(0));
                    break :cc cc;
                },
            };
            reloc.* = try cg.asmJccReloc(cc, undefined);
        }

        for (case.ranges, relocs[case.items.len..]) |range, *reloc| {
            var cond_temp = try cg.tempInit(condition_ty, condition);
            const min_mcv = try cg.resolveInst(range[0]);
            const max_mcv = try cg.resolveInst(range[1]);
            // `null` means always false.
            const lt_min = cc: switch (condition) {
                .eflags => |cc| switch (min_mcv.immediate) {
                    0 => null, // condition never <0
                    1 => cc.negate(),
                    else => unreachable,
                },
                else => {
                    var min_temp = try cg.tempInit(condition_ty, min_mcv);
                    const cc_temp = cond_temp.cmpInts(.lt, &min_temp, cg) catch |err| switch (err) {
                        error.SelectFailed => unreachable,
                        else => |e| return e,
                    };
                    try min_temp.die(cg);
                    const cc = cc_temp.tracking(cg).short.eflags;
                    try cc_temp.die(cg);
                    break :cc cc;
                },
            };
            const lt_min_reloc = if (lt_min) |cc| r: {
                break :r try cg.asmJccReloc(cc, undefined);
            } else null;
            // `null` means always true.
            const lte_max = switch (condition) {
                .eflags => |cc| switch (max_mcv.immediate) {
                    0 => cc.negate(),
                    1 => null, // condition always >=1
                    else => unreachable,
                },
                else => cc: {
                    var max_temp = try cg.tempInit(condition_ty, max_mcv);
                    const cc_temp = cond_temp.cmpInts(.lte, &max_temp, cg) catch |err| switch (err) {
                        error.SelectFailed => unreachable,
                        else => |e| return e,
                    };
                    try max_temp.die(cg);
                    const cc = cc_temp.tracking(cg).short.eflags;
                    try cc_temp.die(cg);
                    break :cc cc;
                },
            };
            try cond_temp.die(cg);
            try cg.resetTemps(@enumFromInt(0));
            // "Success" case is in `reloc`....
            if (lte_max) |cc| {
                reloc.* = try cg.asmJccReloc(cc, undefined);
            } else {
                reloc.* = try cg.asmJmpReloc(undefined);
            }
            // ...and "fail" case falls through to next checks.
            if (lt_min_reloc) |r| cg.performReloc(r);
        }

        cg.checkInvariantsAfterAirInst();

        // The jump to skip this case if the conditions all failed.
        const skip_case_reloc = try cg.asmJmpReloc(undefined);

        for (liveness.deaths[case.idx]) |operand| try cg.processDeath(operand, .{});

        // Relocate all success cases to the body we're about to generate.
        for (relocs) |reloc| cg.performReloc(reloc);
        try cg.genBodyBlock(case.body);
        try cg.restoreState(state, &.{}, .{
            .emit_instructions = false,
            .update_tracking = true,
            .resurrect = true,
            .close_scope = true,
        });

        // Relocate the "skip" branch to fall through to the next case.
        cg.performReloc(skip_case_reloc);
    }
    if (switch_br.else_body_len > 0) {
        const else_body = cases_it.elseBody();

        const else_deaths = liveness.deaths.len - 1;
        for (liveness.deaths[else_deaths]) |operand| try cg.processDeath(operand, .{});

        try cg.genBodyBlock(else_body);
        try cg.restoreState(state, &.{}, .{
            .emit_instructions = false,
            .update_tracking = true,
            .resurrect = true,
            .close_scope = true,
        });
    }
}

fn airSwitchBr(self: *CodeGen, inst: Air.Inst.Index) !void {
    const switch_br = self.air.unwrapSwitch(inst);
    const condition = try self.resolveInst(switch_br.operand);

    // If the condition dies here in this switch instruction, process
    // that death now instead of later as this has an effect on
    // whether it needs to be spilled in the branches
    const condition_dies = self.liveness.operandDies(inst, 0);
    if (condition_dies) {
        if (switch_br.operand.toIndex()) |op_inst| try self.processDeath(op_inst, .{});
    }
    try self.lowerSwitchBr(inst, switch_br, condition, condition_dies, false);

    // We already took care of pl_op.operand earlier, so there's nothing left to do
}

fn airLoopSwitchBr(self: *CodeGen, inst: Air.Inst.Index) !void {
    const switch_br = self.air.unwrapSwitch(inst);
    const condition = try self.resolveInst(switch_br.operand);

    const mat_cond = if (condition.isModifiable() and
        self.reuseOperand(inst, switch_br.operand, 0, condition))
        condition
    else mat_cond: {
        const mat_cond = try self.allocRegOrMem(inst, true);
        try self.genCopy(self.typeOf(switch_br.operand), mat_cond, condition, .{});
        break :mat_cond mat_cond;
    };
    self.inst_tracking.putAssumeCapacityNoClobber(inst, .init(mat_cond));

    // If the condition dies here in this switch instruction, process
    // that death now instead of later as this has an effect on
    // whether it needs to be spilled in the branches
    if (self.liveness.operandDies(inst, 0)) {
        if (switch_br.operand.toIndex()) |op_inst| try self.processDeath(op_inst, .{});
    }

    // Ensure a register is available for dispatch.
    if (!mat_cond.isRegister()) _ = try self.register_manager.allocReg(null, abi.RegisterClass.gp);

    const state = try self.saveState();

    try self.loops.putNoClobber(self.gpa, inst, .{
        .state = state,
        .target = @intCast(self.mir_instructions.len),
    });
    defer assert(self.loops.remove(inst));

    // Stop tracking block result without forgetting tracking info
    try self.freeValue(mat_cond, .{});

    try self.lowerSwitchBr(inst, switch_br, mat_cond, true, true);

    try self.processDeath(inst, .{});
}

fn airSwitchDispatch(self: *CodeGen, inst: Air.Inst.Index) !void {
    const br = self.air.instructions.items(.data)[@intFromEnum(inst)].br;

    const block_ty = self.typeOfIndex(br.block_inst);
    const loop_data = self.loops.getPtr(br.block_inst).?;
    const block_tracking = self.inst_tracking.getPtr(br.block_inst).?;
    {
        try self.getValue(block_tracking.short, null);
        const src_mcv = try self.resolveInst(br.operand);

        if (self.reuseOperandAdvanced(inst, br.operand, 0, src_mcv, br.block_inst)) {
            try self.getValue(block_tracking.short, br.block_inst);
            // .long = .none to avoid merging operand and block result stack frames.
            const current_tracking: InstTracking = .{ .long = .none, .short = src_mcv };
            try current_tracking.materializeUnsafe(self, br.block_inst, block_tracking.*);
            for (current_tracking.getRegs()) |src_reg| self.register_manager.freeReg(src_reg);
        } else {
            try self.getValue(block_tracking.short, br.block_inst);
            try self.genCopy(block_ty, block_tracking.short, try self.resolveInst(br.operand), .{});
        }
    }

    // Process operand death so that it is properly accounted for in the State below.
    if (self.liveness.operandDies(inst, 0)) {
        if (br.operand.toIndex()) |op_inst| try self.processDeath(op_inst, .{});
    }

    try self.restoreState(loop_data.state, &.{}, .{
        .emit_instructions = true,
        .update_tracking = false,
        .resurrect = false,
        .close_scope = false,
    });

    if (self.loop_switches.getPtr(br.block_inst)) |table| {
        const condition_ty = self.typeOf(br.operand);
        const unsigned_condition_ty = try self.pt.intType(.unsigned, self.intInfo(condition_ty).?.bits);
        const condition_mcv = block_tracking.short;
        try self.spillEflagsIfOccupied();
        if (table.min.orderAgainstZero(self.pt.zcu).compare(.neq)) try self.genBinOpMir(
            .{ ._, .sub },
            condition_ty,
            condition_mcv,
            .{ .air_ref = Air.internedToRef(table.min.toIntern()) },
        );
        switch (table.else_relocs) {
            .@"unreachable" => {},
            .forward => |*else_relocs| {
                var cond_temp = try self.tempInit(unsigned_condition_ty, condition_mcv);
                var table_max_temp = try self.tempFromValue(try self.pt.intValue(unsigned_condition_ty, table.len - 1));
                const cc_temp = cond_temp.cmpInts(.gt, &table_max_temp, self) catch |err| switch (err) {
                    error.SelectFailed => unreachable,
                    else => |e| return e,
                };
                try cond_temp.die(self);
                try table_max_temp.die(self);
                try else_relocs.append(self.gpa, try self.asmJccReloc(cc_temp.tracking(self).short.eflags, undefined));
                try cc_temp.die(self);
            },
            .backward => |else_reloc| {
                var cond_temp = try self.tempInit(unsigned_condition_ty, condition_mcv);
                var table_max_temp = try self.tempFromValue(try self.pt.intValue(unsigned_condition_ty, table.len - 1));
                const cc_temp = cond_temp.cmpInts(.gt, &table_max_temp, self) catch |err| switch (err) {
                    error.SelectFailed => unreachable,
                    else => |e| return e,
                };
                try cond_temp.die(self);
                try table_max_temp.die(self);
                _ = try self.asmJccReloc(cc_temp.tracking(self).short.eflags, else_reloc);
                try cc_temp.die(self);
            },
        }
        {
            const condition_index_reg = if (condition_mcv.isRegister()) condition_mcv.getReg().? else cond: {
                const condition_index_reg =
                    RegisterManager.regAtTrackedIndex(@intCast(loop_data.state.free_registers.findFirstSet().?));
                try self.genSetReg(condition_index_reg, condition_ty, condition_mcv, .{});
                break :cond condition_index_reg;
            };
            const condition_index_lock = self.register_manager.lockReg(condition_index_reg);
            defer if (condition_index_lock) |lock| self.register_manager.unlockReg(lock);
            try self.truncateRegister(condition_ty, condition_index_reg);
            const ptr_size = @divExact(self.target.ptrBitWidth(), 8);
            try self.asmMemory(.{ ._mp, .j }, .{
                .base = .table,
                .mod = .{ .rm = .{
                    .size = .ptr,
                    .index = condition_index_reg.toSize(.ptr, self.target),
                    .scale = .fromFactor(@intCast(ptr_size)),
                    .disp = @intCast(table.start * ptr_size),
                } },
            });
        }

        return self.finishAir(inst, .none, .{ br.operand, .none, .none });
    }

    // Emit a jump with a relocation. It will be patched up after the block ends.
    // Leave the jump offset undefined
    _ = try self.asmJmpReloc(loop_data.target);

    // Stop tracking block result without forgetting tracking info
    try self.freeValue(block_tracking.short, .{ .emit_instructions = false });
}

fn performReloc(self: *CodeGen, reloc: Mir.Inst.Index) void {
    const next_inst: u32 = @intCast(self.mir_instructions.len);
    switch (self.mir_instructions.items(.tag)[reloc]) {
        .j => {},
        .pseudo => switch (self.mir_instructions.items(.ops)[reloc]) {
            .pseudo_j_z_and_np_inst, .pseudo_j_nz_or_p_inst => {},
            else => unreachable,
        },
        .lea => switch (self.mir_instructions.items(.ops)[reloc]) {
            .rm => {
                const rx = self.mir_instructions.items(.data)[reloc].rx;
                assert(rx.fixes == ._);
                const mem_info: Mir.Memory.Info = @bitCast(
                    self.mir_extra.items[rx.payload + std.meta.fieldIndex(Mir.Memory, "info").?],
                );
                assert(mem_info.base == .rip_inst);
                self.mir_extra.items[rx.payload + std.meta.fieldIndex(Mir.Memory, "base").?] = next_inst;
                return;
            },
            else => unreachable,
        },
        else => unreachable,
    }
    self.mir_instructions.items(.data)[reloc].inst.inst = next_inst;
}

fn airBr(self: *CodeGen, inst: Air.Inst.Index) !void {
    const zcu = self.pt.zcu;
    const br = self.air.instructions.items(.data)[@intFromEnum(inst)].br;

    const block_ty = self.typeOfIndex(br.block_inst);
    const block_unused =
        !block_ty.hasRuntimeBitsIgnoreComptime(zcu) or self.liveness.isUnused(br.block_inst);
    const block_tracking = self.inst_tracking.getPtr(br.block_inst).?;
    const block_data = self.blocks.getPtr(br.block_inst).?;
    const first_br = block_data.relocs.items.len == 0;
    const block_result = result: {
        if (block_unused) break :result .none;

        if (!first_br) try self.getValue(block_tracking.short, null);
        const src_mcv = try self.resolveInst(br.operand);

        if (self.reuseOperandAdvanced(inst, br.operand, 0, src_mcv, br.block_inst)) {
            if (first_br) break :result src_mcv;

            try self.getValue(block_tracking.short, br.block_inst);
            try InstTracking.materializeUnsafe(
                // .long = .none to avoid merging operand and block result stack frames.
                .{ .long = .none, .short = src_mcv },
                self,
                br.block_inst,
                block_tracking.*,
            );
            try self.freeValue(src_mcv, .{});
            break :result block_tracking.short;
        }

        const dst_mcv = if (first_br) try self.allocRegOrMem(br.block_inst, true) else dst: {
            try self.getValue(block_tracking.short, br.block_inst);
            break :dst block_tracking.short;
        };
        try self.genCopy(block_ty, dst_mcv, try self.resolveInst(br.operand), .{});
        break :result dst_mcv;
    };

    // Process operand death so that it is properly accounted for in the State below.
    if (self.liveness.operandDies(inst, 0)) {
        if (br.operand.toIndex()) |op_inst| try self.processDeath(op_inst, .{});
    }

    if (first_br) {
        block_tracking.* = .init(block_result);
        try self.saveRetroactiveState(&block_data.state);
    } else try self.restoreState(block_data.state, &.{}, .{
        .emit_instructions = true,
        .update_tracking = false,
        .resurrect = false,
        .close_scope = false,
    });

    // Emit a jump with a relocation. It will be patched up after the block ends.
    // Leave the jump offset undefined
    const jmp_reloc = try self.asmJmpReloc(undefined);
    try block_data.relocs.append(self.gpa, jmp_reloc);

    // Stop tracking block result without forgetting tracking info
    try self.freeValue(block_tracking.short, .{ .emit_instructions = false });
}

fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void {
    @setEvalBranchQuota(1_100);
    const pt = self.pt;
    const zcu = pt.zcu;
    const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
    const extra = self.air.extraData(Air.Asm, ty_pl.payload);
    const outputs_len = extra.data.flags.outputs_len;
    var extra_i: usize = extra.end;
    const outputs: []const Air.Inst.Ref = @ptrCast(self.air.extra.items[extra_i..][0..outputs_len]);
    extra_i += outputs.len;
    const inputs: []const Air.Inst.Ref = @ptrCast(self.air.extra.items[extra_i..][0..extra.data.inputs_len]);
    extra_i += inputs.len;

    var result: MCValue = .none;
    var args: std.array_list.Managed(MCValue) = .init(self.gpa);
    try args.ensureTotalCapacity(outputs.len + inputs.len);
    defer {
        for (args.items) |arg| if (arg.getReg()) |reg| self.register_manager.unlockReg(.{
            .tracked_index = RegisterManager.indexOfRegIntoTracked(reg) orelse continue,
        });
        args.deinit();
    }
    var arg_map: std.StringHashMap(u8) = .init(self.gpa);
    try arg_map.ensureTotalCapacity(@intCast(outputs.len + inputs.len));
    defer arg_map.deinit();

    var outputs_extra_i = extra_i;
    for (outputs) |output| {
        const extra_bytes = std.mem.sliceAsBytes(self.air.extra.items[extra_i..]);
        const constraint = std.mem.sliceTo(std.mem.sliceAsBytes(self.air.extra.items[extra_i..]), 0);
        const name = std.mem.sliceTo(extra_bytes[constraint.len + 1 ..], 0);
        // This equation accounts for the fact that even if we have exactly 4 bytes
        // for the string, we still use the next u32 for the null terminator.
        extra_i += (constraint.len + name.len + (2 + 3)) / 4;

        const maybe_inst = switch (output) {
            .none => inst,
            else => null,
        };
        const ty = switch (output) {
            .none => self.typeOfIndex(inst),
            else => self.typeOf(output).childType(zcu),
        };
        const is_read = switch (constraint[0]) {
            '=' => false,
            '+' => read: {
                if (output == .none) return self.fail(
                    "read-write constraint unsupported for asm result: '{s}'",
                    .{constraint},
                );
                break :read true;
            },
            else => return self.fail("invalid constraint: '{s}'", .{constraint}),
        };
        const is_early_clobber = constraint[1] == '&';
        const rest = constraint[@as(usize, 1) + @intFromBool(is_early_clobber) ..];
        const arg_mcv: MCValue = arg_mcv: {
            const arg_maybe_reg: ?Register = if (std.mem.eql(u8, rest, "r") or
                std.mem.eql(u8, rest, "f") or std.mem.eql(u8, rest, "x"))
                registerAlias(
                    self.register_manager.tryAllocReg(maybe_inst, switch (rest[0]) {
                        'r' => abi.RegisterClass.gp,
                        'f' => abi.RegisterClass.x87,
                        'x' => abi.RegisterClass.sse,
                        else => unreachable,
                    }) orelse return self.fail("ran out of registers lowering inline asm", .{}),
                    @intCast(ty.abiSize(zcu)),
                )
            else if (std.mem.eql(u8, rest, "m"))
                if (output != .none) null else return self.fail(
                    "memory constraint unsupported for asm result: '{s}'",
                    .{constraint},
                )
            else if (std.mem.eql(u8, rest, "g") or
                std.mem.eql(u8, rest, "rm") or std.mem.eql(u8, rest, "mr") or
                std.mem.eql(u8, rest, "r,m") or std.mem.eql(u8, rest, "m,r"))
                self.register_manager.tryAllocReg(maybe_inst, abi.RegisterClass.gp) orelse
                    if (output != .none)
                        null
                    else
                        return self.fail("ran out of registers lowering inline asm", .{})
            else if (std.mem.startsWith(u8, rest, "{") and std.mem.endsWith(u8, rest, "}"))
                parseRegName(rest["{".len .. rest.len - "}".len]) orelse
                    return self.fail("invalid register constraint: '{s}'", .{constraint})
            else if (rest.len == 1 and std.ascii.isDigit(rest[0])) {
                const index = std.fmt.charToDigit(rest[0], 10) catch unreachable;
                if (index >= args.items.len) return self.fail("constraint out of bounds: '{s}'", .{
                    constraint,
                });
                break :arg_mcv args.items[index];
            } else return self.fail("invalid constraint: '{s}'", .{constraint});
            break :arg_mcv if (arg_maybe_reg) |reg| .{ .register = reg } else arg: {
                const ptr_mcv = try self.resolveInst(output);
                switch (ptr_mcv) {
                    .immediate => |addr| if (std.math.cast(i32, @as(i64, @bitCast(addr)))) |_|
                        break :arg ptr_mcv.deref(),
                    .register, .register_offset, .lea_frame => break :arg ptr_mcv.deref(),
                    else => {},
                }
                break :arg .{ .indirect = .{ .reg = try self.copyToTmpRegister(.usize, ptr_mcv) } };
            };
        };
        if (arg_mcv.getReg()) |reg| if (RegisterManager.indexOfRegIntoTracked(reg)) |tracked_index| {
            try self.register_manager.getRegIndex(tracked_index, if (output == .none) inst else null);
            _ = self.register_manager.lockRegIndexAssumeUnused(tracked_index);
        };
        if (!std.mem.eql(u8, name, "_"))
            arg_map.putAssumeCapacityNoClobber(name, @intCast(args.items.len));
        args.appendAssumeCapacity(arg_mcv);
        if (output == .none) result = arg_mcv;
        if (is_read) try self.load(arg_mcv, self.typeOf(output), .{ .air_ref = output });
    }

    for (inputs) |input| {
        const input_bytes = std.mem.sliceAsBytes(self.air.extra.items[extra_i..]);
        const constraint = std.mem.sliceTo(input_bytes, 0);
        const name = std.mem.sliceTo(input_bytes[constraint.len + 1 ..], 0);
        // This equation accounts for the fact that even if we have exactly 4 bytes
        // for the string, we still use the next u32 for the null terminator.
        extra_i += (constraint.len + name.len + (2 + 3)) / 4;

        const ty = self.typeOf(input);
        const input_mcv = try self.resolveInst(input);
        const arg_mcv: MCValue = if (std.mem.eql(u8, constraint, "r") or
            std.mem.eql(u8, constraint, "f") or std.mem.eql(u8, constraint, "x"))
        arg: {
            const rc = switch (constraint[0]) {
                'r' => abi.RegisterClass.gp,
                'f' => abi.RegisterClass.x87,
                'x' => abi.RegisterClass.sse,
                else => unreachable,
            };
            if (input_mcv.isRegister() and
                rc.isSet(RegisterManager.indexOfRegIntoTracked(input_mcv.getReg().?).?))
                break :arg input_mcv;
            const reg = try self.register_manager.allocReg(null, rc);
            try self.genSetReg(reg, ty, input_mcv, .{});
            break :arg .{ .register = registerAlias(reg, @intCast(ty.abiSize(zcu))) };
        } else if (std.mem.eql(u8, constraint, "i") or std.mem.eql(u8, constraint, "n"))
            switch (input_mcv) {
                .immediate => |imm| .{ .immediate = imm },
                else => return self.fail("immediate operand requires comptime value: '{s}'", .{
                    constraint,
                }),
            }
        else if (std.mem.eql(u8, constraint, "m")) arg: {
            switch (input_mcv) {
                .memory => |addr| if (std.math.cast(i32, @as(i64, @bitCast(addr)))) |_|
                    break :arg input_mcv,
                .indirect, .load_frame => break :arg input_mcv,
                .load_nav, .load_uav, .load_lazy_sym, .load_extern_func => {},
                else => {
                    const temp_mcv = try self.allocTempRegOrMem(ty, false);
                    try self.genCopy(ty, temp_mcv, input_mcv, .{});
                    break :arg temp_mcv;
                },
            }
            const addr_reg = self.register_manager.tryAllocReg(null, abi.RegisterClass.gp) orelse {
                const temp_mcv = try self.allocTempRegOrMem(ty, false);
                try self.genCopy(ty, temp_mcv, input_mcv, .{});
                break :arg temp_mcv;
            };
            try self.genSetReg(addr_reg, .usize, input_mcv.address(), .{});
            break :arg .{ .indirect = .{ .reg = addr_reg } };
        } else if (std.mem.eql(u8, constraint, "g") or
            std.mem.eql(u8, constraint, "rm") or std.mem.eql(u8, constraint, "mr") or
            std.mem.eql(u8, constraint, "r,m") or std.mem.eql(u8, constraint, "m,r"))
        arg: {
            switch (input_mcv) {
                .register, .indirect, .load_frame => break :arg input_mcv,
                .memory => |addr| if (std.math.cast(i32, @as(i64, @bitCast(addr)))) |_|
                    break :arg input_mcv,
                else => {},
            }
            const temp_mcv = try self.allocTempRegOrMem(ty, true);
            try self.genCopy(ty, temp_mcv, input_mcv, .{});
            break :arg temp_mcv;
        } else if (std.mem.eql(u8, constraint, "X"))
            input_mcv
        else if (std.mem.startsWith(u8, constraint, "{") and std.mem.endsWith(u8, constraint, "}")) arg: {
            const reg = parseRegName(constraint["{".len .. constraint.len - "}".len]) orelse
                return self.fail("invalid register constraint: '{s}'", .{constraint});
            try self.register_manager.getReg(reg, null);
            try self.genSetReg(reg, ty, input_mcv, .{});
            break :arg .{ .register = reg };
        } else if (constraint.len == 1 and std.ascii.isDigit(constraint[0])) arg: {
            const index = std.fmt.charToDigit(constraint[0], 10) catch unreachable;
            if (index >= args.items.len) return self.fail("constraint out of bounds: '{s}'", .{constraint});
            try self.genCopy(ty, args.items[index], input_mcv, .{});
            break :arg args.items[index];
        } else return self.fail("invalid constraint: '{s}'", .{constraint});
        if (arg_mcv.getReg()) |reg| if (RegisterManager.indexOfRegIntoTracked(reg)) |_| {
            _ = self.register_manager.lockReg(reg);
        };
        if (!std.mem.eql(u8, name, "_"))
            arg_map.putAssumeCapacityNoClobber(name, @intCast(args.items.len));
        args.appendAssumeCapacity(arg_mcv);
    }

    const ip = &zcu.intern_pool;
    const aggregate = ip.indexToKey(extra.data.clobbers).aggregate;
    const struct_type: Type = .fromInterned(aggregate.ty);
    switch (aggregate.storage) {
        .elems => |elems| for (elems, 0..) |elem, i| switch (elem) {
            .bool_true => {
                const clobber = struct_type.structFieldName(i, zcu).toSlice(ip).?;
                assert(clobber.len != 0);

                if (std.mem.eql(u8, clobber, "memory") or
                    std.mem.eql(u8, clobber, "fpsr") or
                    std.mem.eql(u8, clobber, "fpcr") or
                    std.mem.eql(u8, clobber, "mxcsr") or
                    std.mem.eql(u8, clobber, "dirflag"))
                {
                    // ok, sure
                } else if (std.mem.eql(u8, clobber, "cc") or
                    std.mem.eql(u8, clobber, "flags") or
                    std.mem.eql(u8, clobber, "eflags") or
                    std.mem.eql(u8, clobber, "rflags"))
                {
                    try self.spillEflagsIfOccupied();
                } else {
                    try self.register_manager.getReg(parseRegName(clobber) orelse
                        return self.fail("invalid clobber: '{s}'", .{clobber}), null);
                }
            },
            .bool_false => continue,
            else => unreachable,
        },
        .repeated_elem => |elem| switch (elem) {
            .bool_true => @panic("TODO"),
            .bool_false => {},
            else => unreachable,
        },
        .bytes => @panic("TODO"),
    }

    const Label = struct {
        target: Mir.Inst.Index = undefined,
        pending_relocs: std.ArrayList(Mir.Inst.Index) = .empty,

        const Kind = enum { definition, reference };

        fn isValid(kind: Kind, name: []const u8) bool {
            for (name, 0..) |c, i| switch (c) {
                else => return false,
                '$' => if (i == 0) return false,
                '.' => {},
                '0'...'9' => if (i == 0) switch (kind) {
                    .definition => if (name.len != 1) return false,
                    .reference => {
                        if (name.len != 2) return false;
                        switch (name[1]) {
                            else => return false,
                            'B', 'F', 'b', 'f' => {},
                        }
                    },
                },
                '@', 'A'...'Z', '_', 'a'...'z' => {},
            };
            return name.len > 0;
        }
    };
    var labels: std.StringHashMapUnmanaged(Label) = .empty;
    defer {
        var label_it = labels.valueIterator();
        while (label_it.next()) |label| label.pending_relocs.deinit(self.gpa);
        labels.deinit(self.gpa);
    }

    const asm_source = std.mem.sliceAsBytes(self.air.extra.items[extra_i..])[0..extra.data.source_len];
    var line_it = std.mem.tokenizeAny(u8, asm_source, "\n\r;");
    next_line: while (line_it.next()) |line| {
        var mnem_it = std.mem.tokenizeAny(u8, line, " \t");
        var prefix: encoder.Instruction.Prefix = .none;
        const mnem_str = while (mnem_it.next()) |mnem_str| {
            if (mnem_str[0] == '#') continue :next_line;
            if (std.mem.startsWith(u8, mnem_str, "//")) continue :next_line;
            if (std.meta.stringToEnum(encoder.Instruction.Prefix, mnem_str)) |pre| {
                if (prefix != .none) return self.fail("extra prefix: '{s}'", .{mnem_str});
                prefix = pre;
                continue;
            }
            if (!std.mem.endsWith(u8, mnem_str, ":")) break mnem_str;
            const label_name = mnem_str[0 .. mnem_str.len - ":".len];
            if (!Label.isValid(.definition, label_name))
                return self.fail("invalid label: '{s}'", .{label_name});
            const label_gop = try labels.getOrPut(self.gpa, label_name);
            if (!label_gop.found_existing) label_gop.value_ptr.* = .{} else {
                const anon = std.ascii.isDigit(label_name[0]);
                if (!anon and label_gop.value_ptr.pending_relocs.items.len == 0)
                    return self.fail("redefined label: '{s}'", .{label_name});
                for (label_gop.value_ptr.pending_relocs.items) |pending_reloc|
                    self.performReloc(pending_reloc);
                if (anon)
                    label_gop.value_ptr.pending_relocs.clearRetainingCapacity()
                else
                    label_gop.value_ptr.pending_relocs.clearAndFree(self.gpa);
            }
            label_gop.value_ptr.target = @intCast(self.mir_instructions.len);
        } else continue;
        if (mnem_str[0] == '.') {
            if (prefix != .none) return self.fail("prefixed directive: '{s} {s}'", .{ @tagName(prefix), mnem_str });
            prefix = .directive;
        }

        var mnem_size: struct {
            op_has_size: std.StaticBitSet(4),
            size: Memory.Size,
            used: bool,
            fn init(size: ?Memory.Size) @This() {
                return .{
                    .op_has_size = if (size) |_| .initFull() else .initEmpty(),
                    .size = size orelse .none,
                    .used = false,
                };
            }
            fn use(size: *@This(), op_index: usize) ?Memory.Size {
                if (!size.op_has_size.isSet(op_index)) return null;
                size.used = true;
                return size.size;
            }
        } = .init(if (prefix == .directive)
            null
        else if (std.mem.endsWith(u8, mnem_str, "b"))
            .byte
        else if (std.mem.endsWith(u8, mnem_str, "w"))
            .word
        else if (std.mem.endsWith(u8, mnem_str, "l"))
            .dword
        else if (std.mem.endsWith(u8, mnem_str, "q") and
            (std.mem.indexOfScalar(u8, "vp", mnem_str[0]) == null or !std.mem.endsWith(u8, mnem_str, "dq")))
            .qword
        else if (std.mem.endsWith(u8, mnem_str, "t"))
            .tbyte
        else
            null);
        var mnem_tag = while (true) break std.meta.stringToEnum(
            encoder.Instruction.Mnemonic,
            mnem_str[0 .. mnem_str.len - @intFromBool(mnem_size.size != .none)],
        ) orelse if (mnem_size.size != .none) {
            mnem_size = .init(null);
            continue;
        } else return self.fail("invalid mnemonic: '{s}'", .{mnem_str});
        fixed_mnem_size: {
            const fixed_mnem_size: Memory.Size = switch (mnem_tag) {
                .clflush => .byte,
                .fldcw, .fnstcw, .fstcw, .fnstsw, .fstsw => .word,
                .fldenv, .fnstenv, .fstenv => .none,
                .frstor, .fsave, .fnsave, .fxrstor, .fxrstor64, .fxsave, .fxsave64 => .none,
                .in => {
                    mnem_size.op_has_size.unset(0);
                    break :fixed_mnem_size;
                },
                .invlpg => .none,
                .invpcid => .xword,
                .ldmxcsr, .stmxcsr, .vldmxcsr, .vstmxcsr => .dword,
                .out => {
                    mnem_size.op_has_size.unset(1);
                    break :fixed_mnem_size;
                },
                else => break :fixed_mnem_size,
            };
            if (mnem_size.size != .none and mnem_size.size != fixed_mnem_size)
                return self.fail("invalid size: '{s}'", .{mnem_str});
            mnem_size = .init(fixed_mnem_size);
        }

        var ops: [4]Operand = @splat(.none);
        var ops_len: usize = 0;

        var last_op = false;
        var op_it = std.mem.splitScalar(u8, mnem_it.rest(), ',');
        next_op: for (&ops, 0..) |*op, op_index| {
            const op_str = while (!last_op) {
                const full_str = op_it.next() orelse break :next_op;
                const code_str = if (std.mem.indexOfScalar(u8, full_str, '#') orelse
                    std.mem.indexOf(u8, full_str, "//")) |comment|
                code: {
                    last_op = true;
                    break :code full_str[0..comment];
                } else full_str;
                const trim_str = std.mem.trim(u8, code_str, " \t*");
                if (trim_str.len > 0) break trim_str;
            } else break;
            if (std.mem.startsWith(u8, op_str, "%%")) {
                const colon = std.mem.indexOfScalarPos(u8, op_str, "%%".len + 2, ':');
                const reg = parseRegName(op_str["%%".len .. colon orelse op_str.len]) orelse
                    return self.fail("invalid register: '{s}'", .{op_str});
                if (colon) |colon_pos| {
                    const disp = std.fmt.parseInt(i32, op_str[colon_pos + ":".len ..], 0) catch
                        return self.fail("invalid displacement: '{s}'", .{op_str});
                    op.* = .{ .mem = .{
                        .base = .{ .reg = reg },
                        .mod = .{ .rm = .{
                            .size = mnem_size.use(op_index) orelse
                                return self.fail("unknown size: '{s}'", .{op_str}),
                            .disp = disp,
                        } },
                    } };
                } else {
                    if (mnem_size.use(op_index)) |size| if (reg.size().bitSize(self.target) != size.bitSize(self.target))
                        return self.fail("invalid register size: '{s}'", .{op_str});
                    op.* = .{ .reg = reg };
                }
            } else if (std.mem.startsWith(u8, op_str, "%[") and std.mem.endsWith(u8, op_str, "]")) {
                const colon = std.mem.indexOfScalarPos(u8, op_str, "%[".len, ':');
                const modifier = if (colon) |colon_pos|
                    op_str[colon_pos + ":".len .. op_str.len - "]".len]
                else
                    "";
                op.* = switch (args.items[
                    arg_map.get(op_str["%[".len .. colon orelse op_str.len - "]".len]) orelse
                        return self.fail("no matching constraint: '{s}'", .{op_str})
                ]) {
                    .immediate => |imm| if (std.mem.eql(u8, modifier, "") or std.mem.eql(u8, modifier, "c"))
                        .{ .imm = .u(imm) }
                    else
                        return self.fail("invalid modifier: '{s}'", .{modifier}),
                    .register => |reg| if (std.mem.eql(u8, modifier, ""))
                        .{ .reg = if (mnem_size.use(op_index)) |size| reg.toSize(size, self.target) else reg }
                    else
                        return self.fail("invalid modifier: '{s}'", .{modifier}),
                    .memory => |addr| if (std.mem.eql(u8, modifier, "") or std.mem.eql(u8, modifier, "P"))
                        .{ .mem = .{
                            .base = .{ .reg = .ds },
                            .mod = .{ .rm = .{
                                .size = mnem_size.use(op_index) orelse
                                    return self.fail("unknown size: '{s}'", .{op_str}),
                                .disp = @intCast(@as(i64, @bitCast(addr))),
                            } },
                        } }
                    else
                        return self.fail("invalid modifier: '{s}'", .{modifier}),
                    .indirect => |reg_off| if (std.mem.eql(u8, modifier, ""))
                        .{ .mem = .{
                            .base = .{ .reg = reg_off.reg },
                            .mod = .{ .rm = .{
                                .size = mnem_size.use(op_index) orelse
                                    return self.fail("unknown size: '{s}'", .{op_str}),
                                .disp = reg_off.off,
                            } },
                        } }
                    else
                        return self.fail("invalid modifier: '{s}'", .{modifier}),
                    .load_frame => |frame_addr| if (std.mem.eql(u8, modifier, ""))
                        .{ .mem = .{
                            .base = .{ .frame = frame_addr.index },
                            .mod = .{ .rm = .{
                                .size = mnem_size.use(op_index) orelse
                                    return self.fail("unknown size: '{s}'", .{op_str}),
                                .disp = frame_addr.off,
                            } },
                        } }
                    else
                        return self.fail("invalid modifier: '{s}'", .{modifier}),
                    .lea_nav => |nav| if (std.mem.eql(u8, modifier, "P"))
                        .{ .reg = try self.copyToTmpRegister(.usize, .{ .lea_nav = nav }) }
                    else
                        return self.fail("invalid modifier: '{s}'", .{modifier}),
                    .lea_uav => |uav| if (std.mem.eql(u8, modifier, "P"))
                        .{ .reg = try self.copyToTmpRegister(.usize, .{ .lea_uav = uav }) }
                    else
                        return self.fail("invalid modifier: '{s}'", .{modifier}),
                    .lea_lazy_sym => |lazy_sym| if (std.mem.eql(u8, modifier, "P"))
                        .{ .reg = try self.copyToTmpRegister(.usize, .{ .lea_lazy_sym = lazy_sym }) }
                    else
                        return self.fail("invalid modifier: '{s}'", .{modifier}),
                    .lea_extern_func => |extern_func| if (std.mem.eql(u8, modifier, "P"))
                        .{ .reg = try self.copyToTmpRegister(.usize, .{ .lea_extern_func = extern_func }) }
                    else
                        return self.fail("invalid modifier: '{s}'", .{modifier}),
                    else => return self.fail("invalid constraint: '{s}'", .{op_str}),
                };
            } else if (std.mem.startsWith(u8, op_str, "$")) {
                op.* = if (std.fmt.parseInt(u64, op_str["$".len..], 0)) |u|
                    .{ .imm = .u(u) }
                else |_| if (std.fmt.parseInt(i32, op_str["$".len..], 0)) |s|
                    .{ .imm = .s(s) }
                else |_|
                    return self.fail("invalid immediate: '{s}'", .{op_str});
            } else if (std.mem.endsWith(u8, op_str, ")")) {
                const open = std.mem.indexOfScalar(u8, op_str, '(') orelse
                    return self.fail("invalid operand: '{s}'", .{op_str});
                var sib_it = std.mem.splitScalar(u8, op_str[open + "(".len .. op_str.len - ")".len], ',');
                const base_str = sib_it.next() orelse
                    return self.fail("invalid memory operand: '{s}'", .{op_str});
                if (base_str.len > 0 and !std.mem.startsWith(u8, base_str, "%%"))
                    return self.fail("invalid memory operand: '{s}'", .{op_str});
                const index_str = sib_it.next() orelse "";
                if (index_str.len > 0 and !std.mem.startsWith(u8, base_str, "%%"))
                    return self.fail("invalid memory operand: '{s}'", .{op_str});
                const scale_str = sib_it.next() orelse "";
                if (index_str.len == 0 and scale_str.len > 0)
                    return self.fail("invalid memory operand: '{s}'", .{op_str});
                const scale: Memory.Scale = if (scale_str.len > 0)
                    switch (std.fmt.parseInt(u4, scale_str, 10) catch
                        return self.fail("invalid scale: '{s}'", .{op_str})) {
                        1 => .@"1",
                        2 => .@"2",
                        4 => .@"4",
                        8 => .@"8",
                        else => return self.fail("invalid scale: '{s}'", .{op_str}),
                    }
                else
                    .@"1";
                if (sib_it.next()) |_| return self.fail("invalid memory operand: '{s}'", .{op_str});
                op.* = if (std.mem.eql(u8, base_str, "%%dx") and index_str.len == 0)
                    .{ .reg = .dx }
                else if (std.mem.eql(u8, base_str, "%%rip") and index_str.len == 0 and
                    Label.isValid(.reference, op_str[0..open]))
                op: {
                    const anon = std.ascii.isDigit(op_str[0]);
                    const label_gop = try labels.getOrPut(self.gpa, op_str[0..if (anon) 1 else open]);
                    if (anon and (op_str[1] == 'b' or op_str[1] == 'B') and !label_gop.found_existing)
                        return self.fail("undefined label: '{s}'", .{op_str});
                    if (!label_gop.found_existing) label_gop.value_ptr.* = .{};
                    const pending_relocs = &label_gop.value_ptr.pending_relocs;
                    if (if (anon)
                        op_str[1] == 'f' or op_str[1] == 'F'
                    else
                        !label_gop.found_existing or pending_relocs.items.len > 0)
                        try pending_relocs.append(self.gpa, @intCast(self.mir_instructions.len));
                    break :op .{ .mem = .{ .base = .{ .rip_inst = label_gop.value_ptr.target } } };
                } else .{ .mem = .{
                    .base = if (base_str.len > 0)
                        .{ .reg = parseRegName(base_str["%%".len..]) orelse
                            return self.fail("invalid base register: '{s}'", .{base_str}) }
                    else
                        .none,
                    .mod = .{ .rm = .{
                        .size = mnem_size.use(op_index) orelse return self.fail("unknown size: '{s}'", .{op_str}),
                        .index = if (index_str.len > 0)
                            parseRegName(index_str["%%".len..]) orelse
                                return self.fail("invalid index register: '{s}'", .{op_str})
                        else
                            .none,
                        .scale = scale,
                        .disp = if (std.mem.startsWith(u8, op_str[0..open], "%[") and
                            std.mem.endsWith(u8, op_str[0..open], "]"))
                        disp: {
                            const colon = std.mem.indexOfScalarPos(u8, op_str[0..open], "%[".len, ':');
                            const modifier = if (colon) |colon_pos|
                                op_str[colon_pos + ":".len .. open - "]".len]
                            else
                                "";
                            break :disp switch (args.items[
                                arg_map.get(op_str["%[".len .. colon orelse open - "]".len]) orelse
                                    return self.fail("no matching constraint: '{s}'", .{op_str})
                            ]) {
                                .immediate => |imm| if (std.mem.eql(u8, modifier, "") or
                                    std.mem.eql(u8, modifier, "c"))
                                    std.math.cast(i32, @as(i64, @bitCast(imm))) orelse
                                        return self.fail("invalid displacement: '{s}'", .{op_str})
                                else
                                    return self.fail("invalid modifier: '{s}'", .{modifier}),
                                else => return self.fail("invalid constraint: '{s}'", .{op_str}),
                            };
                        } else if (open > 0)
                            std.fmt.parseInt(i32, op_str[0..open], 0) catch
                                return self.fail("invalid displacement: '{s}'", .{op_str})
                        else
                            0,
                    } },
                } };
            } else if (Label.isValid(.reference, op_str)) {
                const anon = std.ascii.isDigit(op_str[0]);
                const label_gop = try labels.getOrPut(self.gpa, op_str[0..if (anon) 1 else op_str.len]);
                if (anon and (op_str[1] == 'b' or op_str[1] == 'B') and !label_gop.found_existing)
                    return self.fail("undefined label: '{s}'", .{op_str});
                if (!label_gop.found_existing) label_gop.value_ptr.* = .{};
                const pending_relocs = &label_gop.value_ptr.pending_relocs;
                if (if (anon)
                    op_str[1] == 'f' or op_str[1] == 'F'
                else
                    !label_gop.found_existing or pending_relocs.items.len > 0)
                    try pending_relocs.append(self.gpa, @intCast(self.mir_instructions.len));
                op.* = .{ .inst = label_gop.value_ptr.target };
            } else return self.fail("invalid operand: '{s}'", .{op_str});
            ops_len += 1;
        } else if (op_it.next()) |op_str| return self.fail("extra operand: '{s}'", .{op_str});

        // convert from att syntax to intel syntax
        std.mem.reverse(Operand, ops[0..ops_len]);
        if (mnem_size.size != .none and !mnem_size.used) {
            comptime var max_mnem_len: usize = 0;
            inline for (@typeInfo(encoder.Instruction.Mnemonic).@"enum".fields) |mnem|
                max_mnem_len = @max(mnem.name.len, max_mnem_len);
            var intel_mnem_buf: [max_mnem_len + 1]u8 = undefined;
            const intel_mnem_str = std.fmt.bufPrint(&intel_mnem_buf, "{s}{c}", .{
                @tagName(mnem_tag),
                @as(u8, switch (mnem_size.size) {
                    .byte => 'b',
                    .word => 'w',
                    .dword => 'd',
                    .qword => 'q',
                    .tbyte => 't',
                    else => unreachable,
                }),
            }) catch unreachable;
            if (std.meta.stringToEnum(encoder.Instruction.Mnemonic, intel_mnem_str)) |intel_mnem_tag| mnem_tag = intel_mnem_tag;
        }
        const mnem_name = @tagName(mnem_tag);
        const mnem_fixed_tag: Mir.Inst.FixedTag = if (prefix == .directive)
            .{ ._, .pseudo }
        else for (std.enums.values(Mir.Inst.Fixes)) |fixes| {
            const fixes_name = @tagName(fixes);
            const space_index = std.mem.indexOfScalar(u8, fixes_name, ' ');
            const fixes_prefix = if (space_index) |index|
                std.meta.stringToEnum(encoder.Instruction.Prefix, fixes_name[0..index]).?
            else
                .none;
            if (fixes_prefix != prefix) continue;
            const pattern = fixes_name[if (space_index) |index| index + " ".len else 0..];
            const wildcard_index = std.mem.indexOfScalar(u8, pattern, '_').?;
            const mnem_prefix = pattern[0..wildcard_index];
            const mnem_suffix = pattern[wildcard_index + "_".len ..];
            if (!std.mem.startsWith(u8, mnem_name, mnem_prefix)) continue;
            if (!std.mem.endsWith(u8, mnem_name, mnem_suffix)) continue;
            break .{ fixes, std.meta.stringToEnum(
                Mir.Inst.Tag,
                mnem_name[mnem_prefix.len .. mnem_name.len - mnem_suffix.len],
            ) orelse continue };
        } else {
            assert(prefix != .none); // no combination of fixes produced a known mnemonic
            return self.fail("invalid prefix for mnemonic: '{s} {s}'", .{
                @tagName(prefix), mnem_name,
            });
        };

        (if (prefix == .directive) switch (mnem_tag) {
            .@".cfi_def_cfa" => if (ops[0] == .reg and ops[1] == .imm and ops[2] == .none)
                self.asmPseudoRegisterImmediate(.pseudo_cfi_def_cfa_ri_s, ops[0].reg, ops[1].imm)
            else
                error.InvalidInstruction,
            .@".cfi_def_cfa_register" => if (ops[0] == .reg and ops[1] == .none)
                self.asmPseudoRegister(.pseudo_cfi_def_cfa_register_r, ops[0].reg)
            else
                error.InvalidInstruction,
            .@".cfi_def_cfa_offset" => if (ops[0] == .imm and ops[1] == .none)
                self.asmPseudoImmediate(.pseudo_cfi_def_cfa_offset_i_s, ops[0].imm)
            else
                error.InvalidInstruction,
            .@".cfi_adjust_cfa_offset" => if (ops[0] == .imm and ops[1] == .none)
                self.asmPseudoImmediate(.pseudo_cfi_adjust_cfa_offset_i_s, ops[0].imm)
            else
                error.InvalidInstruction,
            .@".cfi_offset" => if (ops[0] == .reg and ops[1] == .imm and ops[2] == .none)
                self.asmPseudoRegisterImmediate(.pseudo_cfi_offset_ri_s, ops[0].reg, ops[1].imm)
            else
                error.InvalidInstruction,
            .@".cfi_val_offset" => if (ops[0] == .reg and ops[1] == .imm and ops[2] == .none)
                self.asmPseudoRegisterImmediate(.pseudo_cfi_val_offset_ri_s, ops[0].reg, ops[1].imm)
            else
                error.InvalidInstruction,
            .@".cfi_rel_offset" => if (ops[0] == .reg and ops[1] == .imm and ops[2] == .none)
                self.asmPseudoRegisterImmediate(.pseudo_cfi_rel_offset_ri_s, ops[0].reg, ops[1].imm)
            else
                error.InvalidInstruction,
            .@".cfi_register" => if (ops[0] == .reg and ops[1] == .reg and ops[2] == .none)
                self.asmPseudoRegisterRegister(.pseudo_cfi_register_rr, ops[0].reg, ops[1].reg)
            else
                error.InvalidInstruction,
            .@".cfi_restore" => if (ops[0] == .reg and ops[1] == .none)
                self.asmPseudoRegister(.pseudo_cfi_restore_r, ops[0].reg)
            else
                error.InvalidInstruction,
            .@".cfi_undefined" => if (ops[0] == .reg and ops[1] == .none)
                self.asmPseudoRegister(.pseudo_cfi_undefined_r, ops[0].reg)
            else
                error.InvalidInstruction,
            .@".cfi_same_value" => if (ops[0] == .reg and ops[1] == .none)
                self.asmPseudoRegister(.pseudo_cfi_same_value_r, ops[0].reg)
            else
                error.InvalidInstruction,
            .@".cfi_remember_state" => if (ops[0] == .none)
                self.asmPseudo(.pseudo_cfi_remember_state_none)
            else
                error.InvalidInstruction,
            .@".cfi_restore_state" => if (ops[0] == .none)
                self.asmPseudo(.pseudo_cfi_restore_state_none)
            else
                error.InvalidInstruction,
            .@".cfi_escape" => error.InvalidInstruction,
            else => unreachable,
        } else self.asmOps(mnem_fixed_tag, ops)) catch |err| switch (err) {
            error.InvalidInstruction => return self.fail("invalid instruction: '{s} {s} {s} {s} {s}'", .{
                mnem_str,
                @tagName(ops[0]),
                @tagName(ops[1]),
                @tagName(ops[2]),
                @tagName(ops[3]),
            }),
            else => |e| return e,
        };
    }

    var label_it = labels.iterator();
    while (label_it.next()) |label| if (label.value_ptr.pending_relocs.items.len > 0)
        return self.fail("undefined label: '{s}'", .{label.key_ptr.*});

    for (outputs, args.items[0..outputs.len]) |output, arg_mcv| {
        const extra_bytes = std.mem.sliceAsBytes(self.air.extra.items[outputs_extra_i..]);
        const constraint =
            std.mem.sliceTo(std.mem.sliceAsBytes(self.air.extra.items[outputs_extra_i..]), 0);
        const name = std.mem.sliceTo(extra_bytes[constraint.len + 1 ..], 0);
        // This equation accounts for the fact that even if we have exactly 4 bytes
        // for the string, we still use the next u32 for the null terminator.
        outputs_extra_i += (constraint.len + name.len + (2 + 3)) / 4;

        if (output == .none) continue;
        if (arg_mcv != .register) continue;
        if (constraint.len == 2 and std.ascii.isDigit(constraint[1])) continue;
        try self.store(self.typeOf(output), .{ .air_ref = output }, arg_mcv, .{});
    }

    simple: {
        var buf: [Air.Liveness.bpi - 1]Air.Inst.Ref = @splat(.none);
        var buf_index: usize = 0;
        for (outputs) |output| {
            if (output == .none) continue;

            if (buf_index >= buf.len) break :simple;
            buf[buf_index] = output;
            buf_index += 1;
        }
        if (buf_index + inputs.len > buf.len) break :simple;
        @memcpy(buf[buf_index..][0..inputs.len], inputs);
        return self.finishAir(inst, result, buf);
    }
    var bt = self.liveness.iterateBigTomb(inst);
    for (outputs) |output| if (output != .none) try self.feed(&bt, output);
    for (inputs) |input| try self.feed(&bt, input);
    return self.finishAirResult(inst, result);
}

const MoveStrategy = union(enum) {
    move_through_gpr,
    load_store_through_frame,
    load_store: Mir.Inst.FixedTag,
    load_store_x87,
    insert_extract: InsertExtract,
    insert_or_extract_through_gpr: InsertExtract,
    vex_insert_extract: InsertExtract,

    const InsertExtract = struct {
        insert: Mir.Inst.FixedTag,
        extract: Mir.Inst.FixedTag,
    };

    pub fn read(strat: MoveStrategy, cg: *CodeGen, dst_reg: Register, src_mem: Memory) !void {
        switch (strat) {
            .move_through_gpr => {
                const tmp_reg = try cg.register_manager.allocReg(null, abi.RegisterClass.gp);
                try cg.asmRegisterMemory(.{ ._, .movzx }, tmp_reg.to32(), src_mem);
                try cg.asmRegisterRegister(.{ ._d, .mov }, dst_reg, tmp_reg.to32());
            },
            .load_store_through_frame => {
                const tmp_frame_index = try cg.allocFrameIndex(.init(.{
                    .size = 16,
                    .alignment = .@"16",
                }));
                const tmp_reg = try cg.register_manager.allocReg(null, abi.RegisterClass.gp);
                try cg.asmRegisterMemory(.{ ._, .movzx }, tmp_reg.to32(), src_mem);
                try cg.asmMemoryRegister(.{ ._, .mov }, .{
                    .base = .{ .frame = tmp_frame_index },
                    .mod = .{ .rm = .{ .size = .dword } },
                }, tmp_reg.to32());
                try cg.asmRegisterMemory(.{ ._ps, .mova }, dst_reg, .{
                    .base = .{ .frame = tmp_frame_index },
                    .mod = .{ .rm = .{ .size = .xword } },
                });
            },
            .load_store => |tag| {
                if (tag[0] == ._ps and tag[1] == .movl) try cg.asmRegisterRegister(.{ ._ps, .xor }, dst_reg, dst_reg);
                try cg.asmRegisterMemory(tag, switch (tag[1]) {
                    else => dst_reg,
                    .lea => if (dst_reg.size().bitSize(cg.target) >= 32) dst_reg else dst_reg.to32(),
                }, src_mem);
            },
            .load_store_x87 => if (dst_reg != .st0 and cg.register_manager.isKnownRegFree(.st7)) {
                try cg.asmMemory(.{ .f_, .ld }, src_mem);
                switch (dst_reg) {
                    .st1, .st2, .st3, .st4, .st5, .st6 => try cg.asmRegister(.{ .f_p, .st }, @enumFromInt(@intFromEnum(dst_reg) + 1)),
                    .st7 => try cg.asmOpOnly(.{ .f_cstp, .in }),
                    else => unreachable,
                }
            } else {
                try cg.asmRegister(.{ .f_p, .st }, dst_reg);
                try cg.asmMemory(.{ .f_, .ld }, src_mem);
                switch (dst_reg) {
                    .st0 => {},
                    .st1, .st2, .st3, .st4, .st5, .st6, .st7 => try cg.asmRegister(.{ .f_, .xch }, dst_reg),
                    else => unreachable,
                }
            },
            .insert_extract, .insert_or_extract_through_gpr => |ie| {
                try cg.asmRegisterRegister(.{ .p_, .xor }, dst_reg, dst_reg);
                try cg.asmRegisterMemoryImmediate(ie.insert, dst_reg, src_mem, .u(0));
            },
            .vex_insert_extract => |ie| {
                try cg.asmRegisterRegisterRegister(.{ .vp_, .xor }, dst_reg, dst_reg, dst_reg);
                try cg.asmRegisterRegisterMemoryImmediate(ie.insert, dst_reg, dst_reg, src_mem, .u(0));
            },
        }
    }
    pub fn write(strat: MoveStrategy, cg: *CodeGen, dst_mem: Memory, src_reg: Register) !void {
        switch (strat) {
            .move_through_gpr => {
                const tmp_reg = try cg.register_manager.allocReg(null, abi.RegisterClass.gp);
                try cg.asmRegisterRegister(.{ ._d, .mov }, tmp_reg.to32(), src_reg.to128());
                try cg.asmMemoryRegister(.{ ._, .mov }, dst_mem, tmp_reg.toSize(dst_mem.mod.rm.size, cg.target));
            },
            .load_store_through_frame => {
                const tmp_frame_index = try cg.allocFrameIndex(.init(.{
                    .size = 16,
                    .alignment = .@"16",
                }));
                try cg.asmMemoryRegister(.{ ._ps, .mova }, .{
                    .base = .{ .frame = tmp_frame_index },
                    .mod = .{ .rm = .{ .size = .xword } },
                }, src_reg.to128());
                const tmp_reg = try cg.register_manager.allocReg(null, abi.RegisterClass.gp);
                try cg.asmRegisterMemory(.{ ._, .movzx }, tmp_reg.to32(), .{
                    .base = .{ .frame = tmp_frame_index },
                    .mod = .{ .rm = .{ .size = .word } },
                });
                try cg.asmMemoryRegister(.{ ._, .mov }, dst_mem, tmp_reg.toSize(dst_mem.mod.rm.size, cg.target));
            },
            .load_store => |tag| try cg.asmMemoryRegister(tag, dst_mem, src_reg),
            .load_store_x87 => if (cg.register_manager.isKnownRegFree(.st7)) {
                try cg.asmRegister(.{ .f_, .ld }, src_reg);
                try cg.asmMemory(.{ .f_p, .st }, dst_mem);
            } else {
                switch (src_reg) {
                    .st0 => {},
                    .st1, .st2, .st3, .st4, .st5, .st6, .st7 => try cg.asmRegister(.{ .f_, .xch }, src_reg),
                    else => unreachable,
                }
                try cg.asmMemory(.{ .f_p, .st }, dst_mem);
                try cg.asmMemory(.{ .f_, .ld }, dst_mem);
                switch (src_reg) {
                    .st0 => {},
                    .st1, .st2, .st3, .st4, .st5, .st6, .st7 => try cg.asmRegister(.{ .f_, .xch }, src_reg),
                    else => unreachable,
                }
            },
            .insert_extract, .vex_insert_extract => |ie| try cg.asmMemoryRegisterImmediate(ie.extract, dst_mem, src_reg, .u(0)),
            .insert_or_extract_through_gpr => |ie| {
                const tmp_reg = try cg.register_manager.allocReg(null, abi.RegisterClass.gp);
                try cg.asmRegisterRegisterImmediate(ie.extract, tmp_reg.to32(), src_reg.to128(), .u(0));
                try cg.asmMemoryRegister(.{ ._, .mov }, dst_mem, tmp_reg.to16());
            },
        }
    }
};
fn moveStrategy(cg: *CodeGen, ty: Type, class: Register.Class, aligned: bool) !MoveStrategy {
    const pt = cg.pt;
    const zcu = pt.zcu;
    switch (class) {
        .general_purpose, .gphi, .segment => return .{ .load_store = .{ ._, .mov } },
        .x87 => return .load_store_x87,
        .mmx => {},
        .sse => switch (ty.zigTypeTag(zcu)) {
            else => {
                const classes = std.mem.sliceTo(&abi.classifySystemV(ty, zcu, cg.target, .other), .none);
                assert(std.mem.indexOfNone(abi.Class, classes, &.{
                    .integer, .sse, .sseup, .memory, .float, .float_combine,
                }) == null);
                const abi_size = ty.abiSize(zcu);
                if (abi_size < 4 or std.mem.indexOfScalar(abi.Class, classes, .integer) != null) switch (abi_size) {
                    1 => return if (cg.hasFeature(.avx)) .{ .vex_insert_extract = .{
                        .insert = .{ .vp_b, .insr },
                        .extract = .{ .vp_b, .extr },
                    } } else if (cg.hasFeature(.sse4_1)) .{ .insert_extract = .{
                        .insert = .{ .p_b, .insr },
                        .extract = .{ .p_b, .extr },
                    } } else if (cg.hasFeature(.sse2)) .move_through_gpr else .load_store_through_frame,
                    2 => return if (cg.hasFeature(.avx)) .{ .vex_insert_extract = .{
                        .insert = .{ .vp_w, .insr },
                        .extract = .{ .vp_w, .extr },
                    } } else if (cg.hasFeature(.sse4_1)) .{ .insert_extract = .{
                        .insert = .{ .p_w, .insr },
                        .extract = .{ .p_w, .extr },
                    } } else if (cg.hasFeature(.sse2)) .{ .insert_or_extract_through_gpr = .{
                        .insert = .{ .p_w, .insr },
                        .extract = .{ .p_w, .extr },
                    } } else .load_store_through_frame,
                    3...4 => return .{ .load_store = .{ if (cg.hasFeature(.avx))
                        .v_d
                    else if (cg.hasFeature(.sse2))
                        ._d
                    else
                        ._ss, .mov } },
                    5...8 => return .{ .load_store = if (cg.hasFeature(.avx))
                        .{ .v_q, .mov }
                    else if (cg.hasFeature(.sse2))
                        .{ ._q, .mov }
                    else
                        .{ ._ps, .movl } },
                    9...16 => return .{ .load_store = if (cg.hasFeature(.avx))
                        .{ if (aligned) .v_dqa else .v_dqu, .mov }
                    else if (cg.hasFeature(.sse2))
                        .{ if (aligned) ._dqa else ._dqu, .mov }
                    else
                        .{ ._ps, if (aligned) .mova else .movu } },
                    17...32 => if (cg.hasFeature(.avx))
                        return .{ .load_store = .{ if (aligned) .v_dqa else .v_dqu, .mov } },
                    else => {},
                } else switch (abi_size) {
                    4 => return .{ .load_store = if (cg.hasFeature(.avx))
                        .{ .v_ss, .mov }
                    else
                        .{ ._ss, .mov } },
                    5...8 => return .{ .load_store = if (cg.hasFeature(.avx))
                        .{ .v_sd, .mov }
                    else if (cg.hasFeature(.sse2))
                        .{ ._sd, .mov }
                    else
                        .{ ._ps, .movl } },
                    9...16 => return .{ .load_store = if (cg.hasFeature(.avx))
                        .{ .v_pd, if (aligned) .mova else .movu }
                    else if (cg.hasFeature(.sse2))
                        .{ ._pd, if (aligned) .mova else .movu }
                    else
                        .{ ._ps, if (aligned) .mova else .movu } },
                    17...32 => if (cg.hasFeature(.avx))
                        return .{ .load_store = .{ .v_pd, if (aligned) .mova else .movu } },
                    else => {},
                }
            },
            .float => switch (ty.floatBits(cg.target)) {
                16 => return if (cg.hasFeature(.avx)) .{ .vex_insert_extract = .{
                    .insert = .{ .vp_w, .insr },
                    .extract = .{ .vp_w, .extr },
                } } else if (cg.hasFeature(.sse4_1)) .{ .insert_extract = .{
                    .insert = .{ .p_w, .insr },
                    .extract = .{ .p_w, .extr },
                } } else if (cg.hasFeature(.sse2)) .{ .insert_or_extract_through_gpr = .{
                    .insert = .{ .p_w, .insr },
                    .extract = .{ .p_w, .extr },
                } } else .load_store_through_frame,
                32 => return .{ .load_store = if (cg.hasFeature(.avx))
                    .{ .v_ss, .mov }
                else
                    .{ ._ss, .mov } },
                64 => return .{ .load_store = if (cg.hasFeature(.avx))
                    .{ .v_sd, .mov }
                else if (cg.hasFeature(.sse2))
                    .{ ._sd, .mov }
                else
                    .{ ._ps, .movl } },
                128 => return .{ .load_store = if (cg.hasFeature(.avx))
                    .{ if (aligned) .v_dqa else .v_dqu, .mov }
                else if (cg.hasFeature(.sse2))
                    .{ if (aligned) ._dqa else ._dqu, .mov }
                else
                    .{ ._ps, if (aligned) .mova else .movu } },
                else => {},
            },
            .vector => switch (ty.childType(zcu).zigTypeTag(zcu)) {
                .bool => switch (ty.vectorLen(zcu)) {
                    1...8 => return if (cg.hasFeature(.avx)) .{ .vex_insert_extract = .{
                        .insert = .{ .vp_b, .insr },
                        .extract = .{ .vp_b, .extr },
                    } } else if (cg.hasFeature(.sse4_1)) .{ .insert_extract = .{
                        .insert = .{ .p_b, .insr },
                        .extract = .{ .p_b, .extr },
                    } } else if (cg.hasFeature(.sse2)) .move_through_gpr else .load_store_through_frame,
                    9...16 => return if (cg.hasFeature(.avx)) .{ .vex_insert_extract = .{
                        .insert = .{ .vp_w, .insr },
                        .extract = .{ .vp_w, .extr },
                    } } else if (cg.hasFeature(.sse4_1)) .{ .insert_extract = .{
                        .insert = .{ .p_w, .insr },
                        .extract = .{ .p_w, .extr },
                    } } else if (cg.hasFeature(.sse2)) .{ .insert_or_extract_through_gpr = .{
                        .insert = .{ .p_w, .insr },
                        .extract = .{ .p_w, .extr },
                    } } else .load_store_through_frame,
                    17...32 => return .{ .load_store = .{ if (cg.hasFeature(.avx))
                        .v_d
                    else if (cg.hasFeature(.sse2))
                        ._d
                    else
                        ._ss, .mov } },
                    33...64 => return .{ .load_store = if (cg.hasFeature(.avx))
                        .{ .v_q, .mov }
                    else if (cg.hasFeature(.sse2))
                        .{ ._q, .mov }
                    else
                        .{ ._ps, .movl } },
                    65...128 => return .{ .load_store = if (cg.hasFeature(.avx))
                        .{ if (aligned) .v_dqa else .v_dqu, .mov }
                    else if (cg.hasFeature(.sse2))
                        .{ if (aligned) ._dqa else ._dqu, .mov }
                    else
                        .{ ._ps, if (aligned) .mova else .movu } },
                    129...256 => if (cg.hasFeature(.avx))
                        return .{ .load_store = .{ if (aligned) .v_dqa else .v_dqu, .mov } },
                    else => {},
                },
                .int => switch (ty.childType(zcu).intInfo(zcu).bits) {
                    1...8 => switch (ty.vectorLen(zcu)) {
                        1...16 => return .{ .load_store = if (cg.hasFeature(.avx))
                            .{ if (aligned) .v_dqa else .v_dqu, .mov }
                        else if (cg.hasFeature(.sse2))
                            .{ if (aligned) ._dqa else ._dqu, .mov }
                        else
                            .{ ._ps, if (aligned) .mova else .movu } },
                        17...32 => if (cg.hasFeature(.avx))
                            return .{ .load_store = .{ if (aligned) .v_dqa else .v_dqu, .mov } },
                        else => {},
                    },
                    9...16 => switch (ty.vectorLen(zcu)) {
                        1...8 => return .{ .load_store = if (cg.hasFeature(.avx))
                            .{ if (aligned) .v_dqa else .v_dqu, .mov }
                        else if (cg.hasFeature(.sse2))
                            .{ if (aligned) ._dqa else ._dqu, .mov }
                        else
                            .{ ._ps, if (aligned) .mova else .movu } },
                        9...16 => if (cg.hasFeature(.avx))
                            return .{ .load_store = .{ if (aligned) .v_dqa else .v_dqu, .mov } },
                        else => {},
                    },
                    17...32 => switch (ty.vectorLen(zcu)) {
                        1...4 => return .{ .load_store = if (cg.hasFeature(.avx))
                            .{ if (aligned) .v_dqa else .v_dqu, .mov }
                        else if (cg.hasFeature(.sse2))
                            .{ if (aligned) ._dqa else ._dqu, .mov }
                        else
                            .{ ._ps, if (aligned) .mova else .movu } },
                        5...8 => if (cg.hasFeature(.avx))
                            return .{ .load_store = .{ if (aligned) .v_dqa else .v_dqu, .mov } },
                        else => {},
                    },
                    33...64 => switch (ty.vectorLen(zcu)) {
                        1...2 => return .{ .load_store = if (cg.hasFeature(.avx))
                            .{ if (aligned) .v_dqa else .v_dqu, .mov }
                        else if (cg.hasFeature(.sse2))
                            .{ if (aligned) ._dqa else ._dqu, .mov }
                        else
                            .{ ._ps, if (aligned) .mova else .movu } },
                        3...4 => if (cg.hasFeature(.avx))
                            return .{ .load_store = .{ if (aligned) .v_dqa else .v_dqu, .mov } },
                        else => {},
                    },
                    65...128 => switch (ty.vectorLen(zcu)) {
                        1 => return .{ .load_store = if (cg.hasFeature(.avx))
                            .{ if (aligned) .v_dqa else .v_dqu, .mov }
                        else if (cg.hasFeature(.sse2))
                            .{ if (aligned) ._dqa else ._dqu, .mov }
                        else
                            .{ ._ps, if (aligned) .mova else .movu } },
                        2 => if (cg.hasFeature(.avx))
                            return .{ .load_store = .{ if (aligned) .v_dqa else .v_dqu, .mov } },
                        else => {},
                    },
                    129...256 => switch (ty.vectorLen(zcu)) {
                        1 => if (cg.hasFeature(.avx))
                            return .{ .load_store = .{ if (aligned) .v_dqa else .v_dqu, .mov } },
                        else => {},
                    },
                    else => {},
                },
                .pointer, .optional => if (ty.childType(zcu).isPtrAtRuntime(zcu))
                    switch (ty.vectorLen(zcu)) {
                        1...2 => return .{ .load_store = if (cg.hasFeature(.avx))
                            .{ if (aligned) .v_dqa else .v_dqu, .mov }
                        else if (cg.hasFeature(.sse2))
                            .{ if (aligned) ._dqa else ._dqu, .mov }
                        else
                            .{ ._ps, if (aligned) .mova else .movu } },
                        3...4 => if (cg.hasFeature(.avx))
                            return .{ .load_store = .{ if (aligned) .v_dqa else .v_dqu, .mov } },
                        else => {},
                    }
                else
                    unreachable,
                .float => switch (ty.childType(zcu).floatBits(cg.target)) {
                    16 => switch (ty.vectorLen(zcu)) {
                        1...8 => return .{ .load_store = if (cg.hasFeature(.avx))
                            .{ if (aligned) .v_dqa else .v_dqu, .mov }
                        else if (cg.hasFeature(.sse2))
                            .{ if (aligned) ._dqa else ._dqu, .mov }
                        else
                            .{ ._ps, if (aligned) .mova else .movu } },
                        9...16 => if (cg.hasFeature(.avx))
                            return .{ .load_store = .{ if (aligned) .v_dqa else .v_dqu, .mov } },
                        else => {},
                    },
                    32 => switch (ty.vectorLen(zcu)) {
                        1...4 => return .{ .load_store = if (cg.hasFeature(.avx))
                            .{ .v_ps, if (aligned) .mova else .movu }
                        else
                            .{ ._ps, if (aligned) .mova else .movu } },
                        5...8 => if (cg.hasFeature(.avx))
                            return .{ .load_store = .{ .v_ps, if (aligned) .mova else .movu } },
                        else => {},
                    },
                    64 => switch (ty.vectorLen(zcu)) {
                        1...2 => return .{ .load_store = if (cg.hasFeature(.avx))
                            .{ .v_pd, if (aligned) .mova else .movu }
                        else if (cg.hasFeature(.sse2))
                            .{ ._pd, if (aligned) .mova else .movu }
                        else
                            .{ ._ps, if (aligned) .mova else .movu } },
                        3...4 => if (cg.hasFeature(.avx))
                            return .{ .load_store = .{ .v_pd, if (aligned) .mova else .movu } },
                        else => {},
                    },
                    80, 128 => switch (ty.vectorLen(zcu)) {
                        1 => return .{ .load_store = if (cg.hasFeature(.avx))
                            .{ if (aligned) .v_dqa else .v_dqu, .mov }
                        else if (cg.hasFeature(.sse2))
                            .{ if (aligned) ._dqa else ._dqu, .mov }
                        else
                            .{ ._ps, if (aligned) .mova else .movu } },
                        2 => if (cg.hasFeature(.avx))
                            return .{ .load_store = .{ if (aligned) .v_dqa else .v_dqu, .mov } },
                        else => {},
                    },
                    else => {},
                },
                else => {},
            },
        },
        .ip, .cr, .dr => {},
    }
    return cg.fail("TODO moveStrategy for {f}", .{ty.fmt(pt)});
}

const CopyOptions = struct {
    safety: bool = false,
};

fn genCopy(self: *CodeGen, ty: Type, dst_mcv: MCValue, src_mcv: MCValue, opts: CopyOptions) InnerError!void {
    const pt = self.pt;

    const src_lock = if (src_mcv.getReg()) |reg| self.register_manager.lockReg(reg) else null;
    defer if (src_lock) |lock| self.register_manager.unlockReg(lock);

    switch (dst_mcv) {
        .none,
        .unreach,
        .dead,
        .undef,
        .immediate,
        .eflags,
        .register_overflow,
        .register_mask,
        .indirect_load_frame,
        .lea_frame,
        .lea_nav,
        .lea_uav,
        .lea_lazy_sym,
        .lea_extern_func,
        .elementwise_args,
        .reserved_frame,
        .air_ref,
        => unreachable, // unmodifiable destination
        .register => |dst_reg| try self.genSetReg(dst_reg, ty, src_mcv, opts),
        .register_offset => |dst_reg_off| try self.genSetReg(dst_reg_off.reg, ty, switch (src_mcv) {
            .none,
            .unreach,
            .dead,
            .undef,
            .register_overflow,
            .elementwise_args,
            .reserved_frame,
            => unreachable,
            .immediate,
            .register,
            .register_offset,
            .lea_frame,
            => src_mcv.offset(-dst_reg_off.off),
            else => .{ .register_offset = .{
                .reg = try self.copyToTmpRegister(ty, src_mcv),
                .off = -dst_reg_off.off,
            } },
        }, opts),
        inline .register_pair, .register_triple, .register_quadruple => |dst_regs, dst_tag| {
            const src_info: ?struct { addr_reg: Register, addr_lock: RegisterLock } = src_info: switch (src_mcv) {
                .undef, .memory, .indirect, .load_frame => null,
                .register => |src_reg| switch (dst_regs[0].class()) {
                    .general_purpose => switch (src_reg.class()) {
                        else => unreachable,
                        .sse => if (ty.abiSize(pt.zcu) <= 16) {
                            if (self.hasFeature(.avx)) {
                                try self.asmRegisterRegister(.{ .v_q, .mov }, dst_regs[0].to64(), src_reg.to128());
                                try self.asmRegisterRegisterImmediate(.{ .vp_q, .extr }, dst_regs[1].to64(), src_reg.to128(), .u(1));
                            } else if (self.hasFeature(.sse4_1)) {
                                try self.asmRegisterRegister(.{ ._q, .mov }, dst_regs[0].to64(), src_reg.to128());
                                try self.asmRegisterRegisterImmediate(.{ .p_q, .extr }, dst_regs[1].to64(), src_reg.to128(), .u(1));
                            } else if (self.hasFeature(.sse2)) {
                                const tmp_reg = try self.register_manager.allocReg(null, abi.RegisterClass.sse);
                                const tmp_lock = self.register_manager.lockRegAssumeUnused(tmp_reg);
                                defer self.register_manager.unlockReg(tmp_lock);

                                try self.asmRegisterRegister(.{ ._q, .mov }, dst_regs[0].to64(), src_reg.to128());
                                try self.asmRegisterRegister(.{ ._ps, .movhl }, tmp_reg.to128(), src_reg.to128());
                                try self.asmRegisterRegister(.{ ._q, .mov }, dst_regs[1].to64(), tmp_reg.to128());
                            } else {
                                const frame_index = try self.allocFrameIndex(.init(.{
                                    .size = 16,
                                    .alignment = .@"16",
                                }));
                                try self.asmMemoryRegister(.{ ._ps, .mova }, .{
                                    .base = .{ .frame = frame_index },
                                    .mod = .{ .rm = .{ .size = .xword } },
                                }, src_reg.to128());
                                for (dst_regs, 0..) |dst_reg, dst_index| try self.asmRegisterMemory(.{ ._, .mov }, dst_reg.to64(), .{
                                    .base = .{ .frame = frame_index },
                                    .mod = .{ .rm = .{ .size = .qword, .disp = @intCast(8 * dst_index) } },
                                });
                            }
                            return;
                        } else unreachable,
                    },
                    else => unreachable,
                },
                dst_tag => |src_regs| {
                    var remaining: std.StaticBitSet(dst_regs.len) = .initFull();
                    var hazard_regs = src_regs;
                    while (!remaining.eql(.initEmpty())) {
                        var remaining_it = remaining.iterator(.{});
                        next: while (remaining_it.next()) |index| {
                            const dst_reg = dst_regs[index];
                            const dst_id = dst_reg.id();
                            const src_reg = hazard_regs[index];
                            const src_id = src_reg.id();
                            if (dst_id == src_id) {
                                remaining.unset(index);
                                continue;
                            }
                            var mir_tag: Mir.Inst.FixedTag = .{ ._, .mov };
                            var hazard_it = remaining.iterator(.{});
                            while (hazard_it.next()) |hazard_index| {
                                if (dst_id != hazard_regs[hazard_index].id()) continue;
                                for (dst_regs) |clobber_reg| {
                                    if (src_id == clobber_reg.id()) break;
                                } else continue :next;
                                hazard_regs[hazard_index] = src_reg;
                                mir_tag = .{ ._g, .xch };
                            }
                            remaining.unset(index);
                            try self.asmRegisterRegister(mir_tag, dst_reg.to64(), src_reg.to64());
                        }
                    }
                    return;
                },
                .load_nav, .load_uav, .load_lazy_sym, .load_extern_func => {
                    const src_addr_reg =
                        (try self.register_manager.allocReg(null, abi.RegisterClass.gp)).to64();
                    const src_addr_lock = self.register_manager.lockRegAssumeUnused(src_addr_reg);
                    errdefer self.register_manager.unlockReg(src_addr_lock);

                    try self.genSetReg(src_addr_reg, .usize, src_mcv.address(), opts);
                    break :src_info .{ .addr_reg = src_addr_reg, .addr_lock = src_addr_lock };
                },
                .air_ref => |src_ref| return self.genCopy(ty, dst_mcv, try self.resolveInst(src_ref), opts),
                else => return self.fail("TODO implement genCopy for {s} of {f}", .{
                    @tagName(src_mcv), ty.fmt(pt),
                }),
            };
            defer if (src_info) |info| self.register_manager.unlockReg(info.addr_lock);

            for ([_]bool{ false, true }) |emit_hazard| {
                var hazard_count: u3 = 0;
                var part_disp: i32 = 0;
                for (dst_regs, try self.splitType(dst_regs.len, ty), 0..) |dst_reg, dst_ty, part_i| {
                    defer part_disp += @intCast(dst_ty.abiSize(pt.zcu));
                    const is_hazard = if (src_mcv.getReg()) |src_reg|
                        dst_reg.id() == src_reg.id()
                    else if (src_info) |info|
                        dst_reg.id() == info.addr_reg.id()
                    else
                        false;
                    if (is_hazard) hazard_count += 1;
                    if (is_hazard != emit_hazard) continue;
                    try self.genSetReg(dst_reg, dst_ty, switch (src_mcv) {
                        .undef => if (opts.safety and part_i > 0) .{ .register = dst_regs[0] } else .undef,
                        dst_tag => |src_regs| .{ .register = src_regs[part_i] },
                        .memory, .indirect, .load_frame => src_mcv.address().offset(part_disp).deref(),
                        .load_nav,
                        .load_uav,
                        .load_lazy_sym,
                        .load_extern_func,
                        => .{ .indirect = .{
                            .reg = src_info.?.addr_reg,
                            .off = part_disp,
                        } },
                        else => unreachable,
                    }, opts);
                }
                switch (hazard_count) {
                    0 => break,
                    1 => continue,
                    else => unreachable,
                }
            }
        },
        .indirect => |reg_off| try self.genSetMem(
            .{ .reg = reg_off.reg },
            reg_off.off,
            ty,
            src_mcv,
            opts,
        ),
        .memory => {
            switch (dst_mcv) {
                .memory => |addr| if (std.math.cast(i32, @as(i64, @bitCast(addr)))) |small_addr|
                    return self.genSetMem(.{ .reg = .ds }, small_addr, ty, src_mcv, opts),
                .load_nav, .load_uav, .load_lazy_sym, .load_extern_func => {},
                else => unreachable,
            }

            const addr_reg = try self.copyToTmpRegister(.usize, dst_mcv.address());
            const addr_lock = self.register_manager.lockRegAssumeUnused(addr_reg);
            defer self.register_manager.unlockReg(addr_lock);

            try self.genSetMem(.{ .reg = addr_reg }, 0, ty, src_mcv, opts);
        },
        .load_frame => |frame_addr| try self.genSetMem(
            .{ .frame = frame_addr.index },
            frame_addr.off,
            ty,
            src_mcv,
            opts,
        ),
        .load_nav => |nav| try self.genSetMem(.{ .nav = nav }, 0, ty, src_mcv, opts),
        .load_uav => |uav| try self.genSetMem(.{ .uav = uav }, 0, ty, src_mcv, opts),
        .load_lazy_sym => |lazy_sym| try self.genSetMem(.{ .lazy_sym = lazy_sym }, 0, ty, src_mcv, opts),
        .load_extern_func => |extern_func| try self.genSetMem(.{ .extern_func = extern_func }, 0, ty, src_mcv, opts),
    }
}

fn genSetReg(
    self: *CodeGen,
    dst_reg: Register,
    ty: Type,
    src_mcv: MCValue,
    opts: CopyOptions,
) InnerError!void {
    const pt = self.pt;
    const zcu = pt.zcu;
    const abi_size: u32 = @intCast(ty.abiSize(zcu));
    const dst_alias = registerAlias(dst_reg, abi_size);
    if (ty.bitSize(zcu) > dst_alias.size().bitSize(self.target))
        return self.fail("genSetReg called with a value larger than dst_reg", .{});
    switch (src_mcv) {
        .none,
        .unreach,
        .dead,
        .indirect_load_frame,
        .elementwise_args,
        .reserved_frame,
        => unreachable,
        .undef => if (opts.safety) switch (dst_reg.class()) {
            .general_purpose, .gphi => switch (abi_size) {
                1 => try self.asmRegisterImmediate(.{ ._, .mov }, dst_reg.to8(), .u(0xaa)),
                2 => try self.asmRegisterImmediate(.{ ._, .mov }, dst_reg.to16(), .u(0xaaaa)),
                3...4 => try self.asmRegisterImmediate(
                    .{ ._, .mov },
                    dst_reg.to32(),
                    .s(@as(i32, @bitCast(@as(u32, 0xaaaaaaaa)))),
                ),
                5...8 => try self.asmRegisterImmediate(
                    .{ ._, .mov },
                    dst_reg.to64(),
                    .u(0xaaaaaaaaaaaaaaaa),
                ),
                else => unreachable,
            },
            .segment, .mmx, .sse => {
                const full_ty = try pt.vectorType(.{
                    .len = self.vectorSize(.float),
                    .child = .u8_type,
                });
                try self.genSetReg(dst_reg, full_ty, try self.lowerValue(
                    try pt.aggregateSplatValue(full_ty, try pt.intValue(.u8, 0xaa)),
                ), opts);
            },
            .x87 => try self.genSetReg(dst_reg, .f80, try self.lowerValue(
                try pt.floatValue(.f80, @as(f80, @bitCast(@as(u80, 0xaaaaaaaaaaaaaaaaaaaa)))),
            ), opts),
            .ip, .cr, .dr => unreachable,
        },
        .eflags => |cc| try self.asmSetccRegister(cc, dst_reg.to8()),
        .immediate => |imm| {
            if (imm == 0) {
                // 32-bit moves zero-extend to 64-bit, so xoring the 32-bit
                // register is the fastest way to zero a register.
                try self.spillEflagsIfOccupied();
                try self.asmRegisterRegister(.{ ._, .xor }, dst_reg.to32(), dst_reg.to32());
            } else if (abi_size > 4 and std.math.cast(u32, imm) != null) {
                // 32-bit moves zero-extend to 64-bit.
                try self.asmRegisterImmediate(.{ ._, .mov }, dst_reg.to32(), .u(imm));
            } else if (abi_size <= 4 and @as(i64, @bitCast(imm)) < 0) {
                try self.asmRegisterImmediate(
                    .{ ._, .mov },
                    dst_alias,
                    .s(@intCast(@as(i64, @bitCast(imm)))),
                );
            } else {
                try self.asmRegisterImmediate(
                    .{ ._, .mov },
                    dst_alias,
                    .u(imm),
                );
            }
        },
        .register => |src_reg| if (dst_reg.id() != src_reg.id()) switch (dst_reg.class()) {
            .general_purpose => switch (src_reg.class()) {
                .general_purpose => try self.asmRegisterRegister(
                    .{ ._, .mov },
                    dst_alias,
                    registerAlias(src_reg, abi_size),
                ),
                .gphi => if (dst_reg.isClass(.gphi)) try self.asmRegisterRegister(
                    .{ ._, .mov },
                    dst_alias,
                    registerAlias(src_reg, abi_size),
                ) else {
                    const src_lock = self.register_manager.lockReg(src_reg);
                    defer if (src_lock) |lock| self.register_manager.unlockReg(lock);
                    const tmp_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gphi);

                    try self.asmRegisterRegister(.{ ._, .mov }, tmp_reg.to8(), src_reg);
                    try self.asmRegisterRegister(.{ ._, .mov }, dst_alias, tmp_reg.to8());
                },
                .segment => try self.asmRegisterRegister(
                    .{ ._, .mov },
                    dst_alias,
                    src_reg,
                ),
                .x87, .mmx, .ip, .cr, .dr => unreachable,
                .sse => if (self.hasFeature(.sse2)) try self.asmRegisterRegister(
                    switch (abi_size) {
                        1...4 => if (self.hasFeature(.avx)) .{ .v_d, .mov } else .{ ._d, .mov },
                        5...8 => if (self.hasFeature(.avx)) .{ .v_q, .mov } else .{ ._q, .mov },
                        else => unreachable,
                    },
                    registerAlias(dst_reg, @max(abi_size, 4)),
                    src_reg.to128(),
                ) else {
                    const frame_size = std.math.ceilPowerOfTwoAssert(u32, @max(abi_size, 4));
                    const frame_index = try self.allocFrameIndex(.init(.{
                        .size = frame_size,
                        .alignment = .fromNonzeroByteUnits(frame_size),
                    }));
                    try self.asmMemoryRegister(switch (frame_size) {
                        4 => .{ ._ss, .mov },
                        8 => .{ ._ps, .movl },
                        16 => .{ ._ps, .mov },
                        else => unreachable,
                    }, .{
                        .base = .{ .frame = frame_index },
                        .mod = .{ .rm = .{ .size = .fromSize(frame_size) } },
                    }, src_reg.to128());
                    try self.asmRegisterMemory(.{ ._, .mov }, dst_alias, .{
                        .base = .{ .frame = frame_index },
                        .mod = .{ .rm = .{ .size = .fromSize(abi_size) } },
                    });
                },
            },
            .gphi => switch (src_reg.class()) {
                .general_purpose => if (src_reg.isClass(.gphi)) try self.asmRegisterRegister(
                    .{ ._, .mov },
                    dst_alias,
                    registerAlias(src_reg, abi_size),
                ) else {
                    const dst_lock = self.register_manager.lockReg(dst_reg);
                    defer if (dst_lock) |lock| self.register_manager.unlockReg(lock);
                    const tmp_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gphi);

                    try self.asmRegisterRegister(.{ ._, .mov }, tmp_reg.to8(), src_reg.to8());
                    try self.asmRegisterRegister(.{ ._, .mov }, dst_reg, tmp_reg.to8());
                },
                .gphi => try self.asmRegisterRegister(
                    .{ ._, .mov },
                    dst_alias,
                    registerAlias(src_reg, abi_size),
                ),
                .segment, .x87, .mmx, .ip, .cr, .dr, .sse => unreachable,
            },
            .segment => try self.asmRegisterRegister(
                .{ ._, .mov },
                dst_reg,
                switch (src_reg.class()) {
                    .general_purpose, .gphi, .segment => registerAlias(src_reg, abi_size),
                    .x87, .mmx, .ip, .cr, .dr => unreachable,
                    .sse => try self.copyToTmpRegister(ty, src_mcv),
                },
            ),
            .x87 => switch (src_reg.class()) {
                .general_purpose, .gphi, .segment, .mmx, .ip, .cr, .dr => unreachable,
                .x87 => switch (src_reg) {
                    .st0 => try self.asmRegister(.{ .f_, .st }, dst_reg),
                    .st1, .st2, .st3, .st4, .st5, .st6 => switch (dst_reg) {
                        .st0 => {
                            try self.asmRegister(.{ .f_p, .st }, .st0);
                            try self.asmRegister(.{ .f_, .ld }, @enumFromInt(@intFromEnum(src_reg) - 1));
                        },
                        .st2, .st3, .st4, .st5, .st6 => if (self.register_manager.isKnownRegFree(.st7)) {
                            try self.asmRegister(.{ .f_, .ld }, src_reg);
                            try self.asmRegister(.{ .f_p, .st }, @enumFromInt(@intFromEnum(dst_reg) + 1));
                        } else {
                            try self.asmRegister(.{ .f_, .xch }, src_reg);
                            try self.asmRegister(.{ .f_, .xch }, dst_reg);
                            try self.asmRegister(.{ .f_, .xch }, src_reg);
                        },
                        .st7 => {
                            if (!self.register_manager.isKnownRegFree(.st7)) try self.asmRegister(.{ .f_, .free }, dst_reg);
                            try self.asmRegister(.{ .f_, .ld }, src_reg);
                            try self.asmOpOnly(.{ .f_cstp, .in });
                        },
                        else => unreachable,
                    },
                    else => unreachable,
                },
                .sse => if (abi_size <= 16) {
                    const frame_index = try self.allocFrameIndex(.init(.{
                        .size = 16,
                        .alignment = .@"16",
                    }));
                    try self.asmMemoryRegister(if (self.hasFeature(.avx))
                        .{ .v_dqa, .mov }
                    else if (self.hasFeature(.sse2))
                        .{ ._dqa, .mov }
                    else
                        .{ ._ps, .mova }, .{
                        .base = .{ .frame = frame_index },
                        .mod = .{ .rm = .{ .size = .xword } },
                    }, src_reg.to128());
                    try MoveStrategy.read(.load_store_x87, self, dst_reg, .{
                        .base = .{ .frame = frame_index },
                        .mod = .{ .rm = .{ .size = .tbyte } },
                    });
                } else unreachable,
            },
            .mmx => unreachable,
            .sse => switch (src_reg.class()) {
                .general_purpose, .gphi => if (self.hasFeature(.sse2)) try self.asmRegisterRegister(
                    switch (abi_size) {
                        1...4 => if (self.hasFeature(.avx)) .{ .v_d, .mov } else .{ ._d, .mov },
                        5...8 => if (self.hasFeature(.avx)) .{ .v_q, .mov } else .{ ._q, .mov },
                        else => unreachable,
                    },
                    dst_reg.to128(),
                    registerAlias(src_reg, @max(abi_size, 4)),
                ) else {
                    const frame_size = std.math.ceilPowerOfTwoAssert(u32, @max(abi_size, 4));
                    const frame_index = try self.allocFrameIndex(.init(.{
                        .size = frame_size,
                        .alignment = .fromNonzeroByteUnits(frame_size),
                    }));
                    try self.asmMemoryRegister(.{ ._, .mov }, .{
                        .base = .{ .frame = frame_index },
                        .mod = .{ .rm = .{ .size = .fromSize(abi_size) } },
                    }, registerAlias(src_reg, abi_size));
                    switch (frame_size) {
                        else => {},
                        8 => try self.asmRegisterRegister(.{ ._ps, .xor }, dst_reg.to128(), dst_reg.to128()),
                    }
                    try self.asmRegisterMemory(switch (frame_size) {
                        4 => .{ ._ss, .mov },
                        8 => .{ ._ps, .movl },
                        16 => .{ ._ps, .mova },
                        else => unreachable,
                    }, dst_reg.to128(), .{
                        .base = .{ .frame = frame_index },
                        .mod = .{ .rm = .{ .size = .fromSize(frame_size) } },
                    });
                },
                .segment => try self.genSetReg(
                    dst_reg,
                    ty,
                    .{ .register = try self.copyToTmpRegister(ty, src_mcv) },
                    opts,
                ),
                .x87 => if (abi_size <= 16) {
                    const frame_index = try self.allocFrameIndex(.init(.{
                        .size = 16,
                        .alignment = .@"16",
                    }));
                    try MoveStrategy.write(.load_store_x87, self, .{
                        .base = .{ .frame = frame_index },
                        .mod = .{ .rm = .{ .size = .tbyte } },
                    }, src_reg);
                    try self.asmRegisterMemory(if (self.hasFeature(.avx))
                        .{ .v_dqa, .mov }
                    else if (self.hasFeature(.sse2))
                        .{ ._dqa, .mov }
                    else
                        .{ ._ps, .mova }, dst_reg.to128(), .{
                        .base = .{ .frame = frame_index },
                        .mod = .{ .rm = .{ .size = .xword } },
                    });
                } else unreachable,
                .mmx, .ip, .cr, .dr => unreachable,
                .sse => try self.asmRegisterRegister(
                    @as(?Mir.Inst.FixedTag, switch (ty.scalarType(zcu).zigTypeTag(zcu)) {
                        else => switch (abi_size) {
                            1...16 => if (self.hasFeature(.avx))
                                .{ .v_dqa, .mov }
                            else if (self.hasFeature(.sse2))
                                .{ ._dqa, .mov }
                            else
                                .{ ._ps, .mova },
                            17...32 => if (self.hasFeature(.avx)) .{ .v_dqa, .mov } else null,
                            else => null,
                        },
                        .float => switch (ty.scalarType(zcu).floatBits(self.target)) {
                            16, 128 => switch (abi_size) {
                                2...16 => if (self.hasFeature(.avx))
                                    .{ .v_dqa, .mov }
                                else if (self.hasFeature(.sse2))
                                    .{ ._dqa, .mov }
                                else
                                    .{ ._ps, .mova },
                                17...32 => if (self.hasFeature(.avx)) .{ .v_dqa, .mov } else null,
                                else => null,
                            },
                            32 => if (self.hasFeature(.avx)) .{ .v_ps, .mova } else .{ ._ps, .mova },
                            64 => if (self.hasFeature(.avx))
                                .{ .v_pd, .mova }
                            else if (self.hasFeature(.sse2))
                                .{ ._pd, .mova }
                            else
                                .{ ._ps, .mova },
                            80 => null,
                            else => unreachable,
                        },
                    }) orelse return self.fail("TODO implement genSetReg for {f}", .{ty.fmt(pt)}),
                    dst_alias,
                    registerAlias(src_reg, abi_size),
                ),
            },
            .ip, .cr, .dr => unreachable,
        } else if ((dst_reg.class() == .gphi) != (src_reg.class() == .gphi)) try self.asmRegisterRegister(
            .{ ._, .mov },
            dst_reg.to8(),
            src_reg.to8(),
        ),
        inline .register_pair,
        .register_triple,
        .register_quadruple,
        => |src_regs| switch (dst_reg.class()) {
            .general_purpose => switch (src_regs[0].class()) {
                .general_purpose => try self.genSetReg(dst_reg, ty, .{ .register = src_regs[0] }, opts),
                else => unreachable,
            },
            .sse => switch (src_regs[0].class()) {
                .general_purpose => if (abi_size <= 16) {
                    if (self.hasFeature(.avx)) {
                        try self.asmRegisterRegister(.{ .v_q, .mov }, dst_reg.to128(), src_regs[0].to64());
                        try self.asmRegisterRegisterRegisterImmediate(
                            .{ .vp_q, .insr },
                            dst_reg.to128(),
                            dst_reg.to128(),
                            src_regs[1].to64(),
                            .u(1),
                        );
                    } else if (self.hasFeature(.sse4_1)) {
                        try self.asmRegisterRegister(.{ ._q, .mov }, dst_reg.to128(), src_regs[0].to64());
                        try self.asmRegisterRegisterImmediate(.{ .p_q, .insr }, dst_reg.to128(), src_regs[1].to64(), .u(1));
                    } else if (self.hasFeature(.sse2)) {
                        const tmp_reg = try self.register_manager.allocReg(null, abi.RegisterClass.sse);
                        const tmp_lock = self.register_manager.lockRegAssumeUnused(tmp_reg);
                        defer self.register_manager.unlockReg(tmp_lock);

                        try self.asmRegisterRegister(.{ ._q, .mov }, dst_reg.to128(), src_regs[0].to64());
                        try self.asmRegisterRegister(.{ ._q, .mov }, tmp_reg.to128(), src_regs[1].to64());
                        try self.asmRegisterRegister(.{ ._ps, .movlh }, dst_reg.to128(), tmp_reg.to128());
                    } else {
                        const frame_index = try self.allocFrameIndex(.init(.{
                            .size = 16,
                            .alignment = .@"16",
                        }));
                        for (src_regs, 0..) |src_reg, src_index| try self.asmMemoryRegister(.{ ._, .mov }, .{
                            .base = .{ .frame = frame_index },
                            .mod = .{ .rm = .{ .size = .qword, .disp = @intCast(8 * src_index) } },
                        }, src_reg.to64());
                        try self.asmRegisterMemory(.{ ._ps, .mova }, dst_reg.to128(), .{
                            .base = .{ .frame = frame_index },
                            .mod = .{ .rm = .{ .size = .xword } },
                        });
                    }
                } else unreachable,
                else => unreachable,
            },
            else => unreachable,
        },
        .register_offset,
        .indirect,
        .load_frame,
        .lea_frame,
        => try @as(MoveStrategy, switch (src_mcv) {
            .register_offset => |reg_off| switch (reg_off.off) {
                0 => return self.genSetReg(dst_reg, ty, .{ .register = reg_off.reg }, opts),
                else => .{ .load_store = .{ ._, .lea } },
            },
            .indirect => try self.moveStrategy(ty, dst_reg.class(), false),
            .load_frame => |frame_addr| try self.moveStrategy(
                ty,
                dst_reg.class(),
                self.getFrameAddrAlignment(frame_addr).compare(.gte, .fromLog2Units(
                    std.math.log2_int_ceil(u64, @divExact(dst_reg.size().bitSize(self.target), 8)),
                )),
            ),
            .lea_frame => .{ .load_store = .{ ._, .lea } },
            else => unreachable,
        }).read(self, dst_alias, switch (src_mcv) {
            .register_offset, .indirect => |reg_off| .{
                .base = .{ .reg = reg_off.reg.to64() },
                .mod = .{ .rm = .{
                    .size = self.memSize(ty),
                    .disp = reg_off.off,
                } },
            },
            .load_frame, .lea_frame => |frame_addr| .{
                .base = .{ .frame = frame_addr.index },
                .mod = .{ .rm = .{
                    .size = self.memSize(ty),
                    .disp = frame_addr.off,
                } },
            },
            else => unreachable,
        }),
        .register_overflow => |src_reg_ov| {
            const ip = &zcu.intern_pool;
            const first_ty: Type = .fromInterned(first_ty: switch (ip.indexToKey(ty.toIntern())) {
                .tuple_type => |tuple_type| {
                    const tuple_field_types = tuple_type.types.get(ip);
                    assert(tuple_field_types.len == 2 and tuple_field_types[1] == .u1_type);
                    break :first_ty tuple_field_types[0];
                },
                .opt_type => |opt_child| {
                    assert(!ty.optionalReprIsPayload(zcu));
                    break :first_ty opt_child;
                },
                else => std.debug.panic("{s}: {f}\n", .{ @src().fn_name, ty.fmt(pt) }),
            });
            const first_size: u31 = @intCast(first_ty.abiSize(zcu));
            const frame_size = std.math.ceilPowerOfTwoAssert(u32, abi_size);
            const frame_index = try self.allocFrameIndex(.init(.{
                .size = frame_size,
                .alignment = .fromNonzeroByteUnits(frame_size),
            }));
            try self.asmMemoryRegister(.{ ._, .mov }, .{
                .base = .{ .frame = frame_index },
                .mod = .{ .rm = .{ .size = .fromSize(first_size) } },
            }, registerAlias(src_reg_ov.reg, first_size));
            try self.asmSetccMemory(src_reg_ov.eflags, .{
                .base = .{ .frame = frame_index },
                .mod = .{ .rm = .{ .size = .byte, .disp = first_size } },
            });
            try self.asmRegisterMemory(.{ ._, .mov }, registerAlias(dst_reg, abi_size), .{
                .base = .{ .frame = frame_index },
                .mod = .{ .rm = .{ .size = .fromSize(frame_size) } },
            });
        },
        .register_mask => |src_reg_mask| {
            assert(src_reg_mask.reg.isClass(.sse));
            const has_avx = self.hasFeature(.avx);
            const bits_reg = switch (dst_reg.class()) {
                .general_purpose => dst_reg,
                else => try self.register_manager.allocReg(null, abi.RegisterClass.gp),
            };
            const bits_lock = self.register_manager.lockReg(bits_reg);
            defer if (bits_lock) |lock| self.register_manager.unlockReg(lock);

            const pack_reg = switch (src_reg_mask.info.scalar) {
                else => src_reg_mask.reg,
                .word => try self.register_manager.allocReg(null, abi.RegisterClass.sse),
            };
            const pack_lock = self.register_manager.lockReg(pack_reg);
            defer if (pack_lock) |lock| self.register_manager.unlockReg(lock);

            var mask_size: u32 = @intCast(ty.vectorLen(zcu) * @divExact(src_reg_mask.info.scalar.bitSize(self.target), 8));
            switch (src_reg_mask.info.scalar) {
                else => {},
                .word => {
                    const src_alias = registerAlias(src_reg_mask.reg, mask_size);
                    const pack_alias = registerAlias(pack_reg, mask_size);
                    if (has_avx) {
                        try self.asmRegisterRegisterRegister(.{ .vp_b, .ackssw }, pack_alias, src_alias, src_alias);
                    } else {
                        try self.asmRegisterRegister(.{ ._dqa, .mov }, pack_alias, src_alias);
                        try self.asmRegisterRegister(.{ .p_b, .ackssw }, pack_alias, pack_alias);
                    }
                    mask_size = std.math.divCeil(u32, mask_size, 2) catch unreachable;
                },
            }
            try self.asmRegisterRegister(.{ switch (src_reg_mask.info.scalar) {
                .byte, .word => if (has_avx) .vp_b else .p_b,
                .dword => if (has_avx) .v_ps else ._ps,
                .qword => if (has_avx) .v_pd else ._pd,
                else => unreachable,
            }, .movmsk }, bits_reg.to32(), registerAlias(pack_reg, mask_size));
            if (src_reg_mask.info.inverted) try self.asmRegister(.{ ._, .not }, registerAlias(bits_reg, abi_size));
            try self.genSetReg(dst_reg, ty, .{ .register = bits_reg }, .{});
        },
        .memory, .load_nav, .load_uav, .load_lazy_sym, .load_extern_func => {
            switch (src_mcv) {
                .memory => |addr| if (std.math.cast(i32, @as(i64, @bitCast(addr)))) |small_addr|
                    return (try self.moveStrategy(
                        ty,
                        dst_reg.class(),
                        ty.abiAlignment(zcu).check(@as(u32, @bitCast(small_addr))),
                    )).read(self, dst_alias, .{
                        .base = .{ .reg = .ds },
                        .mod = .{ .rm = .{
                            .size = self.memSize(ty),
                            .disp = small_addr,
                        } },
                    }),
                .load_nav => |nav| switch (dst_reg.class()) {
                    .general_purpose, .gphi => {
                        try self.asmRegisterMemory(.{ ._, .mov }, dst_alias, .{
                            .base = .{ .nav = nav },
                            .mod = .{ .rm = .{ .size = self.memSize(ty) } },
                        });
                        return;
                    },
                    .segment, .mmx, .ip, .cr, .dr => unreachable,
                    .x87, .sse => {},
                },
                .load_uav => |uav| switch (dst_reg.class()) {
                    .general_purpose, .gphi => {
                        try self.asmRegisterMemory(.{ ._, .mov }, dst_alias, .{
                            .base = .{ .uav = uav },
                            .mod = .{ .rm = .{ .size = self.memSize(ty) } },
                        });
                        return;
                    },
                    .segment, .mmx, .ip, .cr, .dr => unreachable,
                    .x87, .sse => {},
                },
                .load_lazy_sym => |lazy_sym| switch (dst_reg.class()) {
                    .general_purpose, .gphi => {
                        try self.asmRegisterMemory(.{ ._, .mov }, dst_alias, .{
                            .base = .{ .lazy_sym = lazy_sym },
                            .mod = .{ .rm = .{ .size = self.memSize(ty) } },
                        });
                        return;
                    },
                    .segment, .mmx, .ip, .cr, .dr => unreachable,
                    .x87, .sse => {},
                },
                .load_extern_func => |extern_func| switch (dst_reg.class()) {
                    .general_purpose, .gphi => {
                        try self.asmRegisterMemory(.{ ._, .mov }, dst_alias, .{
                            .base = .{ .extern_func = extern_func },
                            .mod = .{ .rm = .{ .size = self.memSize(ty) } },
                        });
                        return;
                    },
                    .segment, .mmx, .ip, .cr, .dr => unreachable,
                    .x87, .sse => {},
                },
                else => unreachable,
            }

            const addr_reg = try self.copyToTmpRegister(.usize, src_mcv.address());
            const addr_lock = self.register_manager.lockRegAssumeUnused(addr_reg);
            defer self.register_manager.unlockReg(addr_lock);

            try (try self.moveStrategy(ty, dst_reg.class(), false)).read(self, dst_alias, .{
                .base = .{ .reg = addr_reg.to64() },
                .mod = .{ .rm = .{ .size = self.memSize(ty) } },
            });
        },
        .lea_nav => |nav| try self.asmRegisterMemory(.{ ._, .lea }, dst_reg.to64(), .{
            .base = .{ .nav = nav },
        }),
        .lea_uav => |uav| try self.asmRegisterMemory(.{ ._, .lea }, dst_reg.to64(), .{
            .base = .{ .uav = uav },
        }),
        .lea_lazy_sym => |lazy_sym| try self.asmRegisterMemory(.{ ._, .lea }, dst_reg.to64(), .{
            .base = .{ .lazy_sym = lazy_sym },
        }),
        .lea_extern_func => |lazy_sym| try self.asmRegisterMemory(.{ ._, .lea }, dst_reg.to64(), .{
            .base = .{ .extern_func = lazy_sym },
        }),
        .air_ref => |src_ref| try self.genSetReg(dst_reg, ty, try self.resolveInst(src_ref), opts),
    }
}

fn genSetMem(
    self: *CodeGen,
    base: Memory.Base,
    disp: i32,
    ty: Type,
    src_mcv: MCValue,
    opts: CopyOptions,
) InnerError!void {
    const pt = self.pt;
    const zcu = pt.zcu;
    const abi_size: u32 = @intCast(ty.abiSize(zcu));
    const dst_ptr_mcv: MCValue = switch (base) {
        .none => .{ .immediate = @bitCast(@as(i64, disp)) },
        .reg => |base_reg| .{ .register_offset = .{ .reg = base_reg, .off = disp } },
        .frame => |base_frame_index| .{ .lea_frame = .{ .index = base_frame_index, .off = disp } },
        .table, .rip_inst, .lazy_sym => unreachable,
        .nav => |nav| {
            // hack around linker relocation bugs
            const addr_reg = try self.copyToTmpRegister(.usize, .{ .lea_nav = nav });
            const addr_lock = self.register_manager.lockRegAssumeUnused(addr_reg);
            defer self.register_manager.unlockReg(addr_lock);

            return self.genSetMem(.{ .reg = addr_reg }, disp, ty, src_mcv, opts);
        },
        .uav => |uav| .{ .lea_uav = uav },
        .extern_func => |extern_func| .{ .lea_extern_func = extern_func },
    };
    switch (src_mcv) {
        .none,
        .unreach,
        .dead,
        .indirect_load_frame,
        .elementwise_args,
        .reserved_frame,
        => unreachable,
        .undef => if (opts.safety) try self.genInlineMemset(
            dst_ptr_mcv,
            src_mcv,
            .{ .immediate = abi_size },
            opts,
        ),
        .immediate => |imm| switch (abi_size) {
            1, 2, 4 => {
                const immediate: Immediate = switch (if (ty.isAbiInt(zcu))
                    ty.intInfo(zcu).signedness
                else
                    .unsigned) {
                    .signed => .s(@truncate(@as(i64, @bitCast(imm)))),
                    .unsigned => .u(@as(u32, @intCast(imm))),
                };
                try self.asmMemoryImmediate(
                    .{ ._, .mov },
                    .{ .base = base, .mod = .{ .rm = .{
                        .size = .fromSize(abi_size),
                        .disp = disp,
                    } } },
                    immediate,
                );
            },
            3, 5...7 => unreachable,
            else => if (std.math.cast(i32, @as(i64, @bitCast(imm)))) |small| {
                try self.asmMemoryImmediate(
                    .{ ._, .mov },
                    .{ .base = base, .mod = .{ .rm = .{
                        .size = .fromSize(abi_size),
                        .disp = disp,
                    } } },
                    .s(small),
                );
            } else {
                var offset: i32 = 0;
                while (offset < abi_size) : (offset += 4) try self.asmMemoryImmediate(
                    .{ ._, .mov },
                    .{ .base = base, .mod = .{ .rm = .{
                        .size = .dword,
                        .disp = disp + offset,
                    } } },
                    if (ty.isSignedInt(zcu)) .s(
                        @truncate(@as(i64, @bitCast(imm)) >> (std.math.cast(u6, offset * 8) orelse 63)),
                    ) else .u(
                        @as(u32, @truncate(if (std.math.cast(u6, offset * 8)) |shift| imm >> shift else 0)),
                    ),
                );
            },
        },
        .eflags => |cc| try self.asmSetccMemory(cc, .{ .base = base, .mod = .{
            .rm = .{ .size = .byte, .disp = disp },
        } }),
        .register => |src_reg| {
            const ip = &zcu.intern_pool;
            const mem_size = switch (base) {
                .frame => |base_fi| mem_size: {
                    assert(disp >= 0);
                    const frame_abi_size = self.frame_allocs.items(.abi_size)[@intFromEnum(base_fi)];
                    const frame_spill_pad = self.frame_allocs.items(.spill_pad)[@intFromEnum(base_fi)];
                    assert(frame_abi_size - frame_spill_pad - disp >= abi_size);
                    break :mem_size if (frame_abi_size - frame_spill_pad - disp == abi_size) frame_abi_size else abi_size;
                },
                else => abi_size,
            };
            const src_alias = registerAlias(src_reg, @intCast(self.unalignedSize(ty)));
            const src_class = src_alias.class();
            const src_size: Memory.Size = switch (src_class) {
                .general_purpose, .gphi, .segment, .ip, .cr, .dr => src_alias.size(),
                .mmx, .sse => .fromSize(abi_size),
                .x87 => switch (abi.classifySystemV(ty, zcu, self.target, .other)[0]) {
                    else => unreachable,
                    .float => .dword,
                    .float_combine, .sse => .qword,
                    .x87 => .tbyte,
                },
            };
            const src_bit_size = src_size.bitSize(self.target);
            const src_align: InternPool.Alignment = .fromNonzeroByteUnits(std.math.ceilPowerOfTwoAssert(u64, src_bit_size));
            const src_byte_size = @divExact(src_bit_size, 8);
            if (src_byte_size > mem_size) {
                const frame_index = try self.allocFrameIndex(.init(.{
                    .size = src_byte_size,
                    .alignment = src_align,
                }));
                const frame_mcv: MCValue = .{ .load_frame = .{ .index = frame_index } };
                try (try self.moveStrategy(ty, src_class, true)).write(self, .{
                    .base = .{ .frame = frame_index },
                    .mod = .{ .rm = .{ .size = src_size } },
                }, src_alias);
                try self.genSetMem(base, disp, ty, frame_mcv, opts);
                try self.freeValue(frame_mcv, .{});
            } else try (try self.moveStrategy(ty, src_class, switch (base) {
                .none => src_align.check(@as(u32, @bitCast(disp))),
                .reg => |reg| switch (reg) {
                    .es, .cs, .ss, .ds => src_align.check(@as(u32, @bitCast(disp))),
                    else => false,
                },
                .frame => |frame_index| self.getFrameAddrAlignment(.{
                    .index = frame_index,
                    .off = disp,
                }).compare(.gte, src_align),
                .table, .rip_inst, .lazy_sym, .extern_func => unreachable,
                .nav => |nav| ip.getNav(nav).getAlignment().compare(.gte, src_align),
                .uav => |uav| Type.fromInterned(uav.orig_ty).ptrAlignment(zcu).compare(.gte, src_align),
            })).write(self, .{
                .base = base,
                .mod = .{ .rm = .{ .size = src_size, .disp = disp } },
            }, src_alias);
        },
        inline .register_pair, .register_triple, .register_quadruple => |src_regs| {
            var part_disp: i32 = disp;
            for (try self.splitType(src_regs.len, ty), src_regs) |src_ty, src_reg| {
                try self.genSetMem(base, part_disp, src_ty, .{ .register = src_reg }, opts);
                part_disp += @intCast(src_ty.abiSize(zcu));
            }
        },
        .register_overflow => |ro| switch (ty.zigTypeTag(zcu)) {
            .@"struct" => {
                try self.genSetMem(
                    base,
                    disp + @as(i32, @intCast(ty.structFieldOffset(0, zcu))),
                    ty.fieldType(0, zcu),
                    .{ .register = ro.reg },
                    opts,
                );
                try self.genSetMem(
                    base,
                    disp + @as(i32, @intCast(ty.structFieldOffset(1, zcu))),
                    ty.fieldType(1, zcu),
                    .{ .eflags = ro.eflags },
                    opts,
                );
            },
            .optional => {
                assert(!ty.optionalReprIsPayload(zcu));
                const child_ty = ty.optionalChild(zcu);
                try self.genSetMem(base, disp, child_ty, .{ .register = ro.reg }, opts);
                try self.genSetMem(
                    base,
                    disp + @as(i32, @intCast(child_ty.abiSize(zcu))),
                    .bool,
                    .{ .eflags = ro.eflags },
                    opts,
                );
            },
            else => return self.fail("TODO implement genSetMem for {s} of {f}", .{
                @tagName(src_mcv), ty.fmt(pt),
            }),
        },
        .register_offset => |reg_off| {
            const src_reg = self.copyToTmpRegister(ty, src_mcv) catch |err| switch (err) {
                error.OutOfRegisters => {
                    const src_reg = registerAlias(reg_off.reg, abi_size);
                    try self.asmRegisterMemory(.{ ._, .lea }, src_reg, .{
                        .base = .{ .reg = src_reg },
                        .mod = .{ .rm = .{ .disp = reg_off.off } },
                    });
                    try self.genSetMem(base, disp, ty, .{ .register = reg_off.reg }, opts);
                    return self.asmRegisterMemory(.{ ._, .lea }, src_reg, .{
                        .base = .{ .reg = src_reg },
                        .mod = .{ .rm = .{ .disp = -reg_off.off } },
                    });
                },
                else => |e| return e,
            };
            const src_lock = self.register_manager.lockRegAssumeUnused(src_reg);
            defer self.register_manager.unlockReg(src_lock);

            try self.genSetMem(base, disp, ty, .{ .register = src_reg }, opts);
        },
        .register_mask => {
            const src_reg = try self.copyToTmpRegister(ty, src_mcv);
            const src_lock = self.register_manager.lockRegAssumeUnused(src_reg);
            defer self.register_manager.unlockReg(src_lock);

            try self.genSetMem(base, disp, ty, .{ .register = src_reg }, opts);
        },
        .memory,
        .indirect,
        .load_frame,
        .lea_frame,
        .load_nav,
        .lea_nav,
        .load_uav,
        .lea_uav,
        .load_lazy_sym,
        .lea_lazy_sym,
        .load_extern_func,
        .lea_extern_func,
        => switch (abi_size) {
            0 => {},
            1, 2, 4, 8 => {
                const src_reg = try self.copyToTmpRegister(ty, src_mcv);
                const src_lock = self.register_manager.lockRegAssumeUnused(src_reg);
                defer self.register_manager.unlockReg(src_lock);

                try self.genSetMem(base, disp, ty, .{ .register = src_reg }, opts);
            },
            else => try self.genInlineMemcpy(dst_ptr_mcv, src_mcv.address(), .{ .immediate = abi_size }, .{ .no_alias = true }),
        },
        .air_ref => |src_ref| try self.genSetMem(base, disp, ty, try self.resolveInst(src_ref), opts),
    }
}

fn genInlineMemcpy(cg: *CodeGen, dst_ptr: MCValue, src_ptr: MCValue, len: MCValue, opts: struct {
    no_alias: bool,
}) InnerError!void {
    if (opts.no_alias and len == .immediate and cg.useConstMemcpyForSize(len.immediate)) {
        if (try cg.genConstMemcpy(dst_ptr, src_ptr, len.immediate)) {
            return;
        }
    }

    try cg.spillRegisters(&.{ .rsi, .rdi, .rcx });
    try cg.genSetReg(.rsi, .usize, src_ptr, .{});
    try cg.genSetReg(.rdi, .usize, dst_ptr, .{});
    try cg.genSetReg(.rcx, .usize, len, .{});
    try cg.asmOpOnly(.{ .@"rep _sb", .mov });
}

/// Returns `true` iff it would be efficient to use `genConstMemcpy` for a copy
/// of `len` bytes instead of using `rep movsb`.
fn useConstMemcpyForSize(cg: *CodeGen, len: u64) bool {
    // LLVM's threshold here is 8 load/store pairs. However, after that threshold, it typically
    // calls through to `memcpy` instead of emitting `rep movsb`; if we don't have the `fsrm` CPU
    // feature, `rep movsb` has a high startup cost, so is inefficient for small copies. Since we
    // don't currently call compiler_rt in the case of longer copies, we use a higher threshold if
    // we don't have the `fsrm` feature.
    return switch (len) {
        0...128 => true,
        129...256 => cg.hasFeature(.avx) or !cg.hasFeature(.fsrm), // if we have AVX, each pair is 32 bytes
        257...512 => !cg.hasFeature(.fsrm), // the threshold should probably be higher, but I'm being cautious
        else => false,
    };
}
/// If we can trivially copy `len` bytes from `orig_src_ptr` to `dst_ptr` using simple loads and
/// stored through already-free register[s] (i.e. without spilling anything), emits that code and
/// returns `true`. Otherwise, returns `false`, and the caller must lower the operation themselves,
/// for instance with `rep movsb`.
fn genConstMemcpy(
    cg: *CodeGen,
    dst_ptr: MCValue,
    orig_src_ptr: MCValue,
    len: u64,
) !bool {
    if (!dst_ptr.isAddress()) return false;

    const src_reg: ?Register = r: {
        if (orig_src_ptr.isAddress()) break :r null;
        if (orig_src_ptr == .lea_uav or orig_src_ptr == .lea_nav) {
            // To "hack around linker relocation bugs", a `lea_uav` isn't considered an address, but
            // we want to avoid pessimising that case because it's common (e.g. returning constant
            // values over 8 bytes). So if there's a register free, load the source address into it.
            if (cg.register_manager.tryAllocReg(null, abi.RegisterClass.gp)) |src_reg| {
                // We'll actually do the load a little later, in case another register alloc fails.
                break :r src_reg;
            }
        }
        return false;
    };

    // Prevent `src_reg` from aliasing `gp_reg` below.
    const src_lock: ?RegisterLock = if (src_reg) |r| cg.register_manager.lockReg(r) else null;
    defer if (src_lock) |l| cg.register_manager.unlockReg(l);

    const want_sse_reg = len >= 16 and cg.hasFeature(.sse);
    const sse_reg: ?Register = if (want_sse_reg) r: {
        break :r cg.register_manager.tryAllocReg(null, abi.RegisterClass.sse);
    } else null;

    const need_gp_reg = len % 16 != 0 or sse_reg == null;
    const gp_reg: Register = if (need_gp_reg) r: {
        break :r cg.register_manager.tryAllocReg(null, abi.RegisterClass.gp) orelse return false;
    } else undefined;

    const src_ptr: MCValue = src_ptr: {
        const reg = src_reg orelse break :src_ptr orig_src_ptr;
        try cg.asmRegisterMemory(.{ ._, .lea }, reg.to64(), switch (orig_src_ptr) {
            .lea_uav => |uav| .{ .base = .{ .uav = uav } },
            .lea_nav => |nav| .{ .base = .{ .nav = nav } },
            else => unreachable,
        });
        break :src_ptr .{ .register = reg.to64() };
    };

    var offset: u64 = 0;

    if (sse_reg) |r| {
        if (cg.hasFeature(.avx)) {
            try cg.memcpyPart(dst_ptr, src_ptr, len, &offset, .{ .v_dqu, .mov }, r, .yword);
            try cg.memcpyPart(dst_ptr, src_ptr, len, &offset, .{ .v_dqu, .mov }, r, .xword);
        } else if (cg.hasFeature(.sse2)) {
            try cg.memcpyPart(dst_ptr, src_ptr, len, &offset, .{ ._dqu, .mov }, r, .xword);
        } else if (cg.hasFeature(.sse)) {
            try cg.memcpyPart(dst_ptr, src_ptr, len, &offset, .{ ._ps, .movu }, r, .xword);
        }
    }

    if (need_gp_reg) {
        try cg.memcpyPart(dst_ptr, src_ptr, len, &offset, .{ ._, .mov }, gp_reg, .qword);
        try cg.memcpyPart(dst_ptr, src_ptr, len, &offset, .{ ._, .mov }, gp_reg, .dword);
        try cg.memcpyPart(dst_ptr, src_ptr, len, &offset, .{ ._, .mov }, gp_reg, .word);
        try cg.memcpyPart(dst_ptr, src_ptr, len, &offset, .{ ._, .mov }, gp_reg, .byte);
    }

    assert(offset == len);

    return true;
}
fn memcpyPart(
    cg: *CodeGen,
    dst_ptr: MCValue,
    src_ptr: MCValue,
    len: u64,
    offset: *u64,
    tag: Mir.Inst.FixedTag,
    temp_reg: Register,
    size: Memory.Size,
) !void {
    const bytes_len = @divExact(size.bitSize(cg.target), 8);
    while (len - offset.* >= bytes_len) {
        try cg.asmRegisterMemory(
            tag,
            temp_reg.toSize(size, cg.target),
            try src_ptr.deref().mem(cg, .{ .size = size, .disp = @intCast(offset.*) }),
        );
        try cg.asmMemoryRegister(
            tag,
            try dst_ptr.deref().mem(cg, .{ .size = size, .disp = @intCast(offset.*) }),
            temp_reg.toSize(size, cg.target),
        );
        offset.* += bytes_len;
    }
}

fn genInlineMemset(
    self: *CodeGen,
    dst_ptr: MCValue,
    value: MCValue,
    len: MCValue,
    opts: CopyOptions,
) InnerError!void {
    try self.spillRegisters(&.{ .rdi, .al, .rcx });
    try self.genSetReg(.rdi, .usize, dst_ptr, .{});
    try self.genSetReg(.al, .u8, value, opts);
    try self.genSetReg(.rcx, .usize, len, .{});
    try self.asmOpOnly(.{ .@"rep _sb", .sto });
}

fn airBitCast(self: *CodeGen, inst: Air.Inst.Index) !void {
    const pt = self.pt;
    const zcu = pt.zcu;
    const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
    const dst_ty = self.typeOfIndex(inst);
    const src_ty = self.typeOf(ty_op.operand);

    const result = result: {
        const src_mcv = try self.resolveInst(ty_op.operand);
        if (dst_ty.isPtrAtRuntime(zcu) and src_ty.isPtrAtRuntime(zcu)) switch (src_mcv) {
            .lea_frame => break :result src_mcv,
            else => if (self.reuseOperand(inst, ty_op.operand, 0, src_mcv)) break :result src_mcv,
        };

        const dst_rc = self.regSetForType(dst_ty);
        const src_rc = self.regSetForType(src_ty);

        const src_lock = if (src_mcv.getReg()) |src_reg| self.register_manager.lockReg(src_reg) else null;
        defer if (src_lock) |lock| self.register_manager.unlockReg(lock);

        const dst_mcv = if (src_mcv != .register_mask and
            (if (src_mcv.getReg()) |src_reg| src_reg.isClass(.general_purpose) else true) and
            dst_rc.supersetOf(src_rc) and dst_ty.abiSize(zcu) <= src_ty.abiSize(zcu) and
            dst_ty.abiAlignment(zcu).order(src_ty.abiAlignment(zcu)).compare(.lte) and
            self.reuseOperand(inst, ty_op.operand, 0, src_mcv)) src_mcv else dst: {
            const dst_mcv = try self.allocRegOrMem(inst, true);
            try self.genCopy(switch (src_mcv) {
                else => switch (std.math.order(dst_ty.abiSize(zcu), src_ty.abiSize(zcu))) {
                    .lt => dst_ty,
                    .eq => if (!dst_mcv.isBase() or src_mcv.isBase()) dst_ty else src_ty,
                    .gt => src_ty,
                },
                .register_mask => src_ty,
            }, dst_mcv, src_mcv, .{});
            break :dst dst_mcv;
        };

        if (dst_ty.isRuntimeFloat()) break :result dst_mcv;

        if (dst_ty.isAbiInt(zcu) and src_ty.isAbiInt(zcu) and src_ty.zigTypeTag(zcu) != .@"struct" and
            dst_ty.intInfo(zcu).signedness == src_ty.intInfo(zcu).signedness) break :result dst_mcv;

        const abi_size = dst_ty.abiSize(zcu);
        const bit_size = dst_ty.bitSize(zcu);
        if (abi_size * 8 <= bit_size or dst_ty.isVector(zcu)) break :result dst_mcv;

        const dst_limbs_len = std.math.divCeil(u31, @intCast(bit_size), 64) catch unreachable;
        const high_mcv: MCValue = switch (dst_mcv) {
            .register => |dst_reg| .{ .register = dst_reg },
            .register_pair => |dst_regs| .{ .register = dst_regs[1] },
            else => dst_mcv.address().offset((dst_limbs_len - 1) * 8).deref(),
        };
        const high_reg = if (high_mcv.isRegister())
            high_mcv.getReg().?
        else
            try self.copyToTmpRegister(.usize, high_mcv);
        const high_lock = self.register_manager.lockReg(high_reg);
        defer if (high_lock) |lock| self.register_manager.unlockReg(lock);
        try self.truncateRegister(dst_ty, high_reg);
        if (!high_mcv.isRegister()) try self.genCopy(
            if (abi_size <= 8) dst_ty else .usize,
            high_mcv,
            .{ .register = high_reg },
            .{},
        );
        var offset = dst_limbs_len * 8;
        if (offset < abi_size) {
            const dst_signedness: std.builtin.Signedness = if (dst_ty.isAbiInt(zcu))
                dst_ty.intInfo(zcu).signedness
            else
                .unsigned;
            const ext_mcv: MCValue = ext_mcv: switch (dst_signedness) {
                .signed => {
                    try self.asmRegisterImmediate(.{ ._r, .sa }, high_reg, .u(63));
                    break :ext_mcv .{ .register = high_reg };
                },
                .unsigned => .{ .immediate = 0 },
            };
            while (offset < abi_size) : (offset += 8) {
                const limb_mcv: MCValue = switch (dst_mcv) {
                    .register => |dst_reg| .{ .register = dst_reg },
                    .register_pair => |dst_regs| .{ .register = dst_regs[@divExact(offset, 8)] },
                    else => dst_mcv.address().offset(offset).deref(),
                };
                const limb_lock = if (limb_mcv.isRegister())
                    self.register_manager.lockReg(limb_mcv.getReg().?)
                else
                    null;
                defer if (limb_lock) |lock| self.register_manager.unlockReg(lock);
                try self.genCopy(.usize, limb_mcv, ext_mcv, .{});
            }
        }
        break :result dst_mcv;
    };
    return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}

fn airCmpxchg(self: *CodeGen, inst: Air.Inst.Index) !void {
    const pt = self.pt;
    const zcu = pt.zcu;
    const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
    const extra = self.air.extraData(Air.Cmpxchg, ty_pl.payload).data;

    const dst_ty = self.typeOfIndex(inst);
    const ptr_ty = self.typeOf(extra.ptr);
    const val_ty = self.typeOf(extra.expected_value);
    const val_abi_size: u32 = @intCast(val_ty.abiSize(zcu));

    try self.spillRegisters(&.{ .rax, .rdx, .rbx, .rcx });
    const regs_lock = self.register_manager.lockRegsAssumeUnused(4, .{ .rax, .rdx, .rbx, .rcx });
    defer for (regs_lock) |lock| self.register_manager.unlockReg(lock);

    const exp_mcv = try self.resolveInst(extra.expected_value);
    if (val_abi_size > 8) {
        const exp_addr_mcv: MCValue = switch (exp_mcv) {
            .memory, .indirect, .load_frame => exp_mcv.address(),
            else => .{ .register = try self.copyToTmpRegister(.usize, exp_mcv.address()) },
        };
        const exp_addr_lock =
            if (exp_addr_mcv.getReg()) |reg| self.register_manager.lockReg(reg) else null;
        defer if (exp_addr_lock) |lock| self.register_manager.unlockReg(lock);

        try self.genSetReg(.rax, .usize, exp_addr_mcv.deref(), .{});
        try self.genSetReg(.rdx, .usize, exp_addr_mcv.offset(8).deref(), .{});
    } else try self.genSetReg(.rax, val_ty, exp_mcv, .{});

    const new_mcv = try self.resolveInst(extra.new_value);
    const new_reg = if (val_abi_size > 8) new: {
        const new_addr_mcv: MCValue = switch (new_mcv) {
            .memory, .indirect, .load_frame => new_mcv.address(),
            else => .{ .register = try self.copyToTmpRegister(.usize, new_mcv.address()) },
        };
        const new_addr_lock =
            if (new_addr_mcv.getReg()) |reg| self.register_manager.lockReg(reg) else null;
        defer if (new_addr_lock) |lock| self.register_manager.unlockReg(lock);

        try self.genSetReg(.rbx, .usize, new_addr_mcv.deref(), .{});
        try self.genSetReg(.rcx, .usize, new_addr_mcv.offset(8).deref(), .{});
        break :new null;
    } else try self.copyToTmpRegister(val_ty, new_mcv);
    const new_lock = if (new_reg) |reg| self.register_manager.lockRegAssumeUnused(reg) else null;
    defer if (new_lock) |lock| self.register_manager.unlockReg(lock);

    const ptr_mcv = try self.resolveInst(extra.ptr);
    const mem_size: Memory.Size = .fromSize(val_abi_size);
    const ptr_mem: Memory = switch (ptr_mcv) {
        .immediate, .register, .register_offset, .lea_frame => try ptr_mcv.deref().mem(self, .{ .size = mem_size }),
        else => .{
            .base = .{ .reg = try self.copyToTmpRegister(ptr_ty, ptr_mcv) },
            .mod = .{ .rm = .{ .size = mem_size } },
        },
    };
    switch (ptr_mem.mod) {
        .rm => {},
        .off => return self.fail("TODO airCmpxchg with {s}", .{@tagName(ptr_mcv)}),
    }
    const ptr_lock = switch (ptr_mem.base) {
        .none, .frame, .nav, .uav => null,
        .reg => |reg| self.register_manager.lockReg(reg),
        .table, .rip_inst, .lazy_sym, .extern_func => unreachable,
    };
    defer if (ptr_lock) |lock| self.register_manager.unlockReg(lock);

    try self.spillEflagsIfOccupied();
    const null_reg = if (dst_ty.optionalReprIsPayload(zcu) and !self.liveness.isUnused(inst)) null_reg: {
        const null_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp);
        try self.asmRegisterRegister(.{ ._, .xor }, null_reg.to32(), null_reg.to32());
        break :null_reg null_reg;
    } else null;
    const null_lock = if (null_reg) |reg| self.register_manager.lockRegAssumeUnused(reg) else null;
    defer if (null_lock) |lock| self.register_manager.unlockReg(lock);

    if (val_abi_size <= 8) try self.asmMemoryRegister(
        .{ .@"lock _", .cmpxchg },
        ptr_mem,
        registerAlias(new_reg.?, val_abi_size),
    ) else try self.asmMemory(.{ .@"lock _16b", .cmpxchg }, ptr_mem);

    const result: MCValue = result: {
        if (self.liveness.isUnused(inst)) break :result .unreach;

        if (null_reg) |reg| try self.asmCmovccRegisterRegister(
            .e,
            registerAlias(.rax, val_abi_size),
            registerAlias(reg, val_abi_size),
        );

        if (val_abi_size <= 8) {
            if (null_reg) |_| break :result .{ .register = .rax };
            self.eflags_inst = inst;
            break :result .{ .register_overflow = .{ .reg = .rax, .eflags = .ne } };
        }

        const dst_mcv = try self.allocRegOrMem(inst, false);
        try self.genCopy(.usize, dst_mcv, .{ .register = .rax }, .{});
        try self.genCopy(.usize, dst_mcv.address().offset(8).deref(), .{ .register = .rdx }, .{});
        if (null_reg == null) try self.genCopy(.bool, dst_mcv.address().offset(16).deref(), .{ .eflags = .ne }, .{});
        break :result dst_mcv;
    };
    return self.finishAir(inst, result, .{ extra.ptr, extra.expected_value, extra.new_value });
}

fn atomicOp(
    self: *CodeGen,
    ptr_mcv: MCValue,
    val_mcv: MCValue,
    ptr_ty: Type,
    val_ty: Type,
    unused: bool,
    rmw_op: ?std.builtin.AtomicRmwOp,
    order: std.builtin.AtomicOrder,
) InnerError!MCValue {
    const pt = self.pt;
    const zcu = pt.zcu;
    const ptr_lock = switch (ptr_mcv) {
        .register => |reg| self.register_manager.lockReg(reg),
        else => null,
    };
    defer if (ptr_lock) |lock| self.register_manager.unlockReg(lock);

    const val_lock = switch (val_mcv) {
        .register => |reg| self.register_manager.lockReg(reg),
        else => null,
    };
    defer if (val_lock) |lock| self.register_manager.unlockReg(lock);

    const val_abi_size: u32 = @intCast(val_ty.abiSize(zcu));
    const mem_size: Memory.Size = .fromSize(val_abi_size);
    const ptr_mem: Memory = switch (ptr_mcv) {
        .immediate, .register, .register_offset, .lea_frame => try ptr_mcv.deref().mem(self, .{ .size = mem_size }),
        else => .{
            .base = .{ .reg = try self.copyToTmpRegister(ptr_ty, ptr_mcv) },
            .mod = .{ .rm = .{ .size = mem_size } },
        },
    };
    switch (ptr_mem.mod) {
        .rm => {},
        .off => return self.fail("TODO airCmpxchg with {s}", .{@tagName(ptr_mcv)}),
    }
    const mem_lock = switch (ptr_mem.base) {
        .none, .frame, .nav, .uav => null,
        .reg => |reg| self.register_manager.lockReg(reg),
        .table, .rip_inst, .lazy_sym, .extern_func => unreachable,
    };
    defer if (mem_lock) |lock| self.register_manager.unlockReg(lock);

    const use_sse = rmw_op orelse .Xchg != .Xchg and val_ty.isRuntimeFloat();
    const strat: enum { lock, loop, libcall } = if (use_sse) .loop else switch (rmw_op orelse .Xchg) {
        .Xchg,
        .Add,
        .Sub,
        => if (val_abi_size <= 8) .lock else if (val_abi_size <= 16) .loop else .libcall,
        .And,
        .Or,
        .Xor,
        => if (val_abi_size <= 8 and unused) .lock else if (val_abi_size <= 16) .loop else .libcall,
        .Nand,
        .Max,
        .Min,
        => if (val_abi_size <= 16) .loop else .libcall,
    };
    switch (strat) {
        .lock => {
            const mir_tag: Mir.Inst.FixedTag = if (rmw_op) |op| switch (op) {
                .Xchg => if (unused) .{ ._, .mov } else .{ ._g, .xch },
                .Add => .{ .@"lock _", if (unused) .add else .xadd },
                .Sub => .{ .@"lock _", if (unused) .sub else .xadd },
                .And => .{ .@"lock _", .@"and" },
                .Or => .{ .@"lock _", .@"or" },
                .Xor => .{ .@"lock _", .xor },
                else => unreachable,
            } else switch (order) {
                .unordered, .monotonic, .release, .acq_rel => .{ ._, .mov },
                .acquire => unreachable,
                .seq_cst => .{ ._g, .xch },
            };

            const dst_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp);
            const dst_mcv = MCValue{ .register = dst_reg };
            const dst_lock = self.register_manager.lockRegAssumeUnused(dst_reg);
            defer self.register_manager.unlockReg(dst_lock);

            try self.genSetReg(dst_reg, val_ty, val_mcv, .{});
            if (rmw_op == std.builtin.AtomicRmwOp.Sub and mir_tag[1] == .xadd) {
                try self.genUnOpMir(.{ ._, .neg }, val_ty, dst_mcv);
            }
            try self.asmMemoryRegister(mir_tag, ptr_mem, registerAlias(dst_reg, val_abi_size));

            return if (unused) .unreach else dst_mcv;
        },
        .loop => _ = if (val_abi_size <= 8) {
            const sse_reg: Register = if (use_sse)
                try self.register_manager.allocReg(null, abi.RegisterClass.sse)
            else
                undefined;
            const sse_lock =
                if (use_sse) self.register_manager.lockRegAssumeUnused(sse_reg) else undefined;
            defer if (use_sse) self.register_manager.unlockReg(sse_lock);

            const tmp_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp);
            const tmp_mcv = MCValue{ .register = tmp_reg };
            const tmp_lock = self.register_manager.lockRegAssumeUnused(tmp_reg);
            defer self.register_manager.unlockReg(tmp_lock);

            try self.asmRegisterMemory(.{ ._, .mov }, registerAlias(.rax, val_abi_size), ptr_mem);
            const loop: Mir.Inst.Index = @intCast(self.mir_instructions.len);
            if (!use_sse and rmw_op orelse .Xchg != .Xchg) {
                try self.genSetReg(tmp_reg, val_ty, .{ .register = .rax }, .{});
            }
            if (rmw_op) |op| if (use_sse) {
                const mir_tag = @as(?Mir.Inst.FixedTag, switch (op) {
                    .Add => switch (val_ty.floatBits(self.target)) {
                        32 => if (self.hasFeature(.avx)) .{ .v_ss, .add } else .{ ._ss, .add },
                        64 => if (self.hasFeature(.avx)) .{ .v_sd, .add } else .{ ._sd, .add },
                        else => null,
                    },
                    .Sub => switch (val_ty.floatBits(self.target)) {
                        32 => if (self.hasFeature(.avx)) .{ .v_ss, .sub } else .{ ._ss, .sub },
                        64 => if (self.hasFeature(.avx)) .{ .v_sd, .sub } else .{ ._sd, .sub },
                        else => null,
                    },
                    .Min => switch (val_ty.floatBits(self.target)) {
                        32 => if (self.hasFeature(.avx)) .{ .v_ss, .min } else .{ ._ss, .min },
                        64 => if (self.hasFeature(.avx)) .{ .v_sd, .min } else .{ ._sd, .min },
                        else => null,
                    },
                    .Max => switch (val_ty.floatBits(self.target)) {
                        32 => if (self.hasFeature(.avx)) .{ .v_ss, .max } else .{ ._ss, .max },
                        64 => if (self.hasFeature(.avx)) .{ .v_sd, .max } else .{ ._sd, .max },
                        else => null,
                    },
                    else => unreachable,
                }) orelse return self.fail("TODO implement atomicOp of {s} for {f}", .{
                    @tagName(op), val_ty.fmt(pt),
                });
                try self.genSetReg(sse_reg, val_ty, .{ .register = .rax }, .{});
                switch (mir_tag[0]) {
                    .v_ss, .v_sd => if (val_mcv.isBase()) try self.asmRegisterRegisterMemory(
                        mir_tag,
                        sse_reg.to128(),
                        sse_reg.to128(),
                        try val_mcv.mem(self, .{ .size = self.memSize(val_ty) }),
                    ) else try self.asmRegisterRegisterRegister(
                        mir_tag,
                        sse_reg.to128(),
                        sse_reg.to128(),
                        (if (val_mcv.isRegister())
                            val_mcv.getReg().?
                        else
                            try self.copyToTmpRegister(val_ty, val_mcv)).to128(),
                    ),
                    ._ss, ._sd => if (val_mcv.isBase()) try self.asmRegisterMemory(
                        mir_tag,
                        sse_reg.to128(),
                        try val_mcv.mem(self, .{ .size = self.memSize(val_ty) }),
                    ) else try self.asmRegisterRegister(
                        mir_tag,
                        sse_reg.to128(),
                        (if (val_mcv.isRegister())
                            val_mcv.getReg().?
                        else
                            try self.copyToTmpRegister(val_ty, val_mcv)).to128(),
                    ),
                    else => unreachable,
                }
                try self.genSetReg(tmp_reg, val_ty, .{ .register = sse_reg }, .{});
            } else switch (op) {
                .Xchg => try self.genSetReg(tmp_reg, val_ty, val_mcv, .{}),
                .Add => try self.genBinOpMir(.{ ._, .add }, val_ty, tmp_mcv, val_mcv),
                .Sub => try self.genBinOpMir(.{ ._, .sub }, val_ty, tmp_mcv, val_mcv),
                .And => try self.genBinOpMir(.{ ._, .@"and" }, val_ty, tmp_mcv, val_mcv),
                .Nand => {
                    try self.genBinOpMir(.{ ._, .@"and" }, val_ty, tmp_mcv, val_mcv);
                    try self.genUnOpMir(.{ ._, .not }, val_ty, tmp_mcv);
                },
                .Or => try self.genBinOpMir(.{ ._, .@"or" }, val_ty, tmp_mcv, val_mcv),
                .Xor => try self.genBinOpMir(.{ ._, .xor }, val_ty, tmp_mcv, val_mcv),
                .Min, .Max => {
                    const cc: Condition = switch (if (val_ty.isAbiInt(zcu))
                        val_ty.intInfo(zcu).signedness
                    else
                        .unsigned) {
                        .unsigned => switch (op) {
                            .Min => .a,
                            .Max => .b,
                            else => unreachable,
                        },
                        .signed => switch (op) {
                            .Min => .g,
                            .Max => .l,
                            else => unreachable,
                        },
                    };

                    const cmov_abi_size = @max(val_abi_size, 2);
                    switch (val_mcv) {
                        .register => |val_reg| {
                            try self.genBinOpMir(.{ ._, .cmp }, val_ty, tmp_mcv, val_mcv);
                            try self.asmCmovccRegisterRegister(
                                cc,
                                registerAlias(tmp_reg, cmov_abi_size),
                                registerAlias(val_reg, cmov_abi_size),
                            );
                        },
                        .memory, .indirect, .load_frame => {
                            try self.genBinOpMir(.{ ._, .cmp }, val_ty, tmp_mcv, val_mcv);
                            try self.asmCmovccRegisterMemory(
                                cc,
                                registerAlias(tmp_reg, cmov_abi_size),
                                try val_mcv.mem(self, .{ .size = .fromSize(cmov_abi_size) }),
                            );
                        },
                        else => {
                            const mat_reg = try self.copyToTmpRegister(val_ty, val_mcv);
                            const mat_lock = self.register_manager.lockRegAssumeUnused(mat_reg);
                            defer self.register_manager.unlockReg(mat_lock);

                            try self.genBinOpMir(
                                .{ ._, .cmp },
                                val_ty,
                                tmp_mcv,
                                .{ .register = mat_reg },
                            );
                            try self.asmCmovccRegisterRegister(
                                cc,
                                registerAlias(tmp_reg, cmov_abi_size),
                                registerAlias(mat_reg, cmov_abi_size),
                            );
                        },
                    }
                },
            };
            try self.asmMemoryRegister(
                .{ .@"lock _", .cmpxchg },
                ptr_mem,
                registerAlias(tmp_reg, val_abi_size),
            );
            _ = try self.asmJccReloc(.ne, loop);
            return if (unused) .unreach else .{ .register = .rax };
        } else {
            try self.asmRegisterMemory(.{ ._, .mov }, .rax, .{
                .base = ptr_mem.base,
                .mod = .{ .rm = .{
                    .size = .qword,
                    .index = ptr_mem.mod.rm.index,
                    .scale = ptr_mem.mod.rm.scale,
                    .disp = ptr_mem.mod.rm.disp + 0,
                } },
            });
            try self.asmRegisterMemory(.{ ._, .mov }, .rdx, .{
                .base = ptr_mem.base,
                .mod = .{ .rm = .{
                    .size = .qword,
                    .index = ptr_mem.mod.rm.index,
                    .scale = ptr_mem.mod.rm.scale,
                    .disp = ptr_mem.mod.rm.disp + 8,
                } },
            });
            const loop: Mir.Inst.Index = @intCast(self.mir_instructions.len);
            const val_mem_mcv: MCValue = switch (val_mcv) {
                .memory, .indirect, .load_frame => val_mcv,
                else => .{ .indirect = .{
                    .reg = try self.copyToTmpRegister(.usize, val_mcv.address()),
                } },
            };
            const val_lo_mem = try val_mem_mcv.mem(self, .{ .size = .qword });
            const val_hi_mem = try val_mem_mcv.address().offset(8).deref().mem(self, .{ .size = .qword });
            if (rmw_op != std.builtin.AtomicRmwOp.Xchg) {
                try self.asmRegisterRegister(.{ ._, .mov }, .rbx, .rax);
                try self.asmRegisterRegister(.{ ._, .mov }, .rcx, .rdx);
            }
            if (rmw_op) |op| switch (op) {
                .Xchg => {
                    try self.asmRegisterMemory(.{ ._, .mov }, .rbx, val_lo_mem);
                    try self.asmRegisterMemory(.{ ._, .mov }, .rcx, val_hi_mem);
                },
                .Add => {
                    try self.asmRegisterMemory(.{ ._, .add }, .rbx, val_lo_mem);
                    try self.asmRegisterMemory(.{ ._, .adc }, .rcx, val_hi_mem);
                },
                .Sub => {
                    try self.asmRegisterMemory(.{ ._, .sub }, .rbx, val_lo_mem);
                    try self.asmRegisterMemory(.{ ._, .sbb }, .rcx, val_hi_mem);
                },
                .And => {
                    try self.asmRegisterMemory(.{ ._, .@"and" }, .rbx, val_lo_mem);
                    try self.asmRegisterMemory(.{ ._, .@"and" }, .rcx, val_hi_mem);
                },
                .Nand => {
                    try self.asmRegisterMemory(.{ ._, .@"and" }, .rbx, val_lo_mem);
                    try self.asmRegisterMemory(.{ ._, .@"and" }, .rcx, val_hi_mem);
                    try self.asmRegister(.{ ._, .not }, .rbx);
                    try self.asmRegister(.{ ._, .not }, .rcx);
                },
                .Or => {
                    try self.asmRegisterMemory(.{ ._, .@"or" }, .rbx, val_lo_mem);
                    try self.asmRegisterMemory(.{ ._, .@"or" }, .rcx, val_hi_mem);
                },
                .Xor => {
                    try self.asmRegisterMemory(.{ ._, .xor }, .rbx, val_lo_mem);
                    try self.asmRegisterMemory(.{ ._, .xor }, .rcx, val_hi_mem);
                },
                .Min, .Max => {
                    const cc: Condition = switch (if (val_ty.isAbiInt(zcu))
                        val_ty.intInfo(zcu).signedness
                    else
                        .unsigned) {
                        .unsigned => switch (op) {
                            .Min => .a,
                            .Max => .b,
                            else => unreachable,
                        },
                        .signed => switch (op) {
                            .Min => .g,
                            .Max => .l,
                            else => unreachable,
                        },
                    };

                    const tmp_reg = try self.copyToTmpRegister(.usize, .{ .register = .rcx });
                    const tmp_lock = self.register_manager.lockRegAssumeUnused(tmp_reg);
                    defer self.register_manager.unlockReg(tmp_lock);

                    try self.asmRegisterMemory(.{ ._, .cmp }, .rbx, val_lo_mem);
                    try self.asmRegisterMemory(.{ ._, .sbb }, tmp_reg, val_hi_mem);
                    try self.asmCmovccRegisterMemory(cc, .rbx, val_lo_mem);
                    try self.asmCmovccRegisterMemory(cc, .rcx, val_hi_mem);
                },
            };
            try self.asmMemory(.{ .@"lock _16b", .cmpxchg }, ptr_mem);
            _ = try self.asmJccReloc(.ne, loop);

            if (unused) return .unreach;
            const dst_mcv = try self.allocTempRegOrMem(val_ty, false);
            try self.asmMemoryRegister(.{ ._, .mov }, .{
                .base = .{ .frame = dst_mcv.load_frame.index },
                .mod = .{ .rm = .{
                    .size = .qword,
                    .disp = dst_mcv.load_frame.off + 0,
                } },
            }, .rax);
            try self.asmMemoryRegister(.{ ._, .mov }, .{
                .base = .{ .frame = dst_mcv.load_frame.index },
                .mod = .{ .rm = .{
                    .size = .qword,
                    .disp = dst_mcv.load_frame.off + 8,
                } },
            }, .rdx);
            return dst_mcv;
        },
        .libcall => return self.fail("TODO implement x86 atomic libcall", .{}),
    }
}

fn airAtomicRmw(self: *CodeGen, inst: Air.Inst.Index) !void {
    const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
    const extra = self.air.extraData(Air.AtomicRmw, pl_op.payload).data;

    try self.spillRegisters(&.{ .rax, .rdx, .rbx, .rcx });
    const regs_lock = self.register_manager.lockRegsAssumeUnused(4, .{ .rax, .rdx, .rbx, .rcx });
    defer for (regs_lock) |lock| self.register_manager.unlockReg(lock);

    const unused = self.liveness.isUnused(inst);

    const ptr_ty = self.typeOf(pl_op.operand);
    const ptr_mcv = try self.resolveInst(pl_op.operand);

    const val_ty = self.typeOf(extra.operand);
    const val_mcv = try self.resolveInst(extra.operand);

    const result =
        try self.atomicOp(ptr_mcv, val_mcv, ptr_ty, val_ty, unused, extra.op(), extra.ordering());
    return self.finishAir(inst, result, .{ pl_op.operand, extra.operand, .none });
}

fn airAtomicLoad(self: *CodeGen, inst: Air.Inst.Index) !void {
    const atomic_load = self.air.instructions.items(.data)[@intFromEnum(inst)].atomic_load;
    const result: MCValue = result: {
        const ptr_ty = self.typeOf(atomic_load.ptr);
        const ptr_mcv = try self.resolveInst(atomic_load.ptr);
        const ptr_lock = switch (ptr_mcv) {
            .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
            else => null,
        };
        defer if (ptr_lock) |lock| self.register_manager.unlockReg(lock);

        const unused = self.liveness.isUnused(inst);

        const dst_mcv: MCValue = if (unused)
            .{ .register = try self.register_manager.allocReg(null, self.regSetForType(ptr_ty.childType(self.pt.zcu))) }
        else if (self.reuseOperand(inst, atomic_load.ptr, 0, ptr_mcv))
            ptr_mcv
        else
            try self.allocRegOrMem(inst, true);

        try self.load(dst_mcv, ptr_ty, ptr_mcv);

        break :result if (unused) .unreach else dst_mcv;
    };
    return self.finishAir(inst, result, .{ atomic_load.ptr, .none, .none });
}

fn airAtomicStore(self: *CodeGen, inst: Air.Inst.Index, order: std.builtin.AtomicOrder) !void {
    const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;

    const ptr_ty = self.typeOf(bin_op.lhs);
    const ptr_mcv = try self.resolveInst(bin_op.lhs);

    const val_ty = self.typeOf(bin_op.rhs);
    const val_mcv = try self.resolveInst(bin_op.rhs);

    const result = try self.atomicOp(ptr_mcv, val_mcv, ptr_ty, val_ty, true, null, order);
    return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}

fn airMemset(self: *CodeGen, inst: Air.Inst.Index, safety: bool) !void {
    const pt = self.pt;
    const zcu = pt.zcu;
    const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;

    result: {
        if (!safety and (try self.resolveInst(bin_op.rhs)) == .undef) break :result;

        try self.spillRegisters(&.{ .rax, .rdi, .rsi, .rcx });
        const reg_locks = self.register_manager.lockRegsAssumeUnused(4, .{ .rax, .rdi, .rsi, .rcx });
        defer for (reg_locks) |lock| self.register_manager.unlockReg(lock);

        const dst = try self.resolveInst(bin_op.lhs);
        const dst_ty = self.typeOf(bin_op.lhs);
        const dst_locks: [2]?RegisterLock = switch (dst) {
            .register => |dst_reg| .{ self.register_manager.lockRegAssumeUnused(dst_reg), null },
            .register_pair => |dst_regs| .{
                self.register_manager.lockRegAssumeUnused(dst_regs[0]),
                self.register_manager.lockRegAssumeUnused(dst_regs[1]),
            },
            else => @splat(null),
        };
        for (dst_locks) |dst_lock| if (dst_lock) |lock| self.register_manager.unlockReg(lock);

        const src_val = try self.resolveInst(bin_op.rhs);
        const elem_ty = self.typeOf(bin_op.rhs);
        const src_val_lock: ?RegisterLock = switch (src_val) {
            .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
            else => null,
        };
        defer if (src_val_lock) |lock| self.register_manager.unlockReg(lock);

        const elem_abi_size: u31 = @intCast(elem_ty.abiSize(zcu));

        if (elem_abi_size == 1) {
            const dst_ptr: MCValue = switch (dst_ty.ptrSize(zcu)) {
                .slice => switch (dst) {
                    .register_pair => |dst_regs| .{ .register = dst_regs[0] },
                    else => dst,
                },
                .one => dst,
                .c, .many => unreachable,
            };
            const len: MCValue = switch (dst_ty.ptrSize(zcu)) {
                .slice => switch (dst) {
                    .register_pair => |dst_regs| .{ .register = dst_regs[1] },
                    else => dst.address().offset(8).deref(),
                },
                .one => .{ .immediate = dst_ty.childType(zcu).arrayLen(zcu) },
                .c, .many => unreachable,
            };
            const len_lock: ?RegisterLock = switch (len) {
                .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
                else => null,
            };
            defer if (len_lock) |lock| self.register_manager.unlockReg(lock);

            try self.genInlineMemset(dst_ptr, src_val, len, .{ .safety = safety });
            break :result;
        }

        // Store the first element, and then rely on memcpy copying forwards.
        // Length zero requires a runtime check - so we handle arrays specially
        // here to elide it.
        switch (dst_ty.ptrSize(zcu)) {
            .slice => {
                const slice_ptr_ty = dst_ty.slicePtrFieldType(zcu);

                const dst_ptr: MCValue = switch (dst) {
                    .register_pair => |dst_regs| .{ .register = dst_regs[0] },
                    else => dst,
                };
                const len: MCValue = switch (dst) {
                    .register_pair => |dst_regs| .{ .register = dst_regs[1] },
                    else => dst.address().offset(8).deref(),
                };

                // Used to store the number of elements for comparison.
                // After comparison, updated to store number of bytes needed to copy.
                const len_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp);
                const len_mcv: MCValue = .{ .register = len_reg };
                const len_lock = self.register_manager.lockRegAssumeUnused(len_reg);
                defer self.register_manager.unlockReg(len_lock);

                try self.genSetReg(len_reg, .usize, len, .{});
                try self.asmRegisterRegister(.{ ._, .@"test" }, len_reg, len_reg);

                const skip_reloc = try self.asmJccReloc(.z, undefined);
                try self.store(slice_ptr_ty, dst_ptr, src_val, .{ .safety = safety });

                const second_elem_ptr_reg =
                    try self.register_manager.allocReg(null, abi.RegisterClass.gp);
                const second_elem_ptr_mcv: MCValue = .{ .register = second_elem_ptr_reg };
                const second_elem_ptr_lock =
                    self.register_manager.lockRegAssumeUnused(second_elem_ptr_reg);
                defer self.register_manager.unlockReg(second_elem_ptr_lock);

                try self.genSetReg(second_elem_ptr_reg, .usize, .{ .register_offset = .{
                    .reg = try self.copyToTmpRegister(.usize, dst_ptr),
                    .off = elem_abi_size,
                } }, .{});

                try self.genBinOpMir(.{ ._, .sub }, .usize, len_mcv, .{ .immediate = 1 });
                try self.asmRegisterRegisterImmediate(
                    .{ .i_, .mul },
                    len_reg,
                    len_reg,
                    .s(elem_abi_size),
                );
                try self.genInlineMemcpy(second_elem_ptr_mcv, dst_ptr, len_mcv, .{ .no_alias = false });

                self.performReloc(skip_reloc);
            },
            .one => {
                const elem_ptr_ty = try pt.singleMutPtrType(elem_ty);

                const len = dst_ty.childType(zcu).arrayLen(zcu);

                assert(len != 0); // prevented by Sema
                try self.store(elem_ptr_ty, dst, src_val, .{ .safety = safety });

                const second_elem_ptr_reg =
                    try self.register_manager.allocReg(null, abi.RegisterClass.gp);
                const second_elem_ptr_mcv: MCValue = .{ .register = second_elem_ptr_reg };
                const second_elem_ptr_lock =
                    self.register_manager.lockRegAssumeUnused(second_elem_ptr_reg);
                defer self.register_manager.unlockReg(second_elem_ptr_lock);

                try self.genSetReg(second_elem_ptr_reg, .usize, .{ .register_offset = .{
                    .reg = try self.copyToTmpRegister(.usize, dst),
                    .off = elem_abi_size,
                } }, .{});

                const bytes_to_copy: MCValue = .{ .immediate = elem_abi_size * (len - 1) };
                try self.genInlineMemcpy(second_elem_ptr_mcv, dst, bytes_to_copy, .{ .no_alias = false });
            },
            .c, .many => unreachable,
        }
    }
    return self.finishAir(inst, .unreach, .{ bin_op.lhs, bin_op.rhs, .none });
}

fn airSplat(self: *CodeGen, inst: Air.Inst.Index) !void {
    const pt = self.pt;
    const zcu = pt.zcu;
    const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
    const vector_ty = self.typeOfIndex(inst);
    const vector_len = vector_ty.vectorLen(zcu);
    const scalar_ty = self.typeOf(ty_op.operand);

    const result: MCValue = result: {
        if (scalar_ty.toIntern() != .bool_type) return self.fail("TODO implement airSplat for {f}", .{
            vector_ty.fmt(pt),
        });
        const regs =
            try self.register_manager.allocRegs(2, .{ inst, null }, abi.RegisterClass.gp);
        const reg_locks = self.register_manager.lockRegsAssumeUnused(2, regs);
        defer for (reg_locks) |lock| self.register_manager.unlockReg(lock);

        try self.genSetReg(regs[1], vector_ty, .{ .immediate = 0 }, .{});
        try self.genSetReg(
            regs[1],
            vector_ty,
            .{ .immediate = @as(u64, std.math.maxInt(u64)) >> @intCast(64 - vector_len) },
            .{},
        );
        const src_mcv = try self.resolveInst(ty_op.operand);
        const abi_size = @max(std.math.divCeil(u32, vector_len, 8) catch unreachable, 4);
        try self.asmCmovccRegisterRegister(
            switch (src_mcv) {
                .eflags => |cc| cc,
                .register => |src_reg| cc: {
                    try self.asmRegisterImmediate(.{ ._, .@"test" }, src_reg.to8(), .u(1));
                    break :cc .nz;
                },
                else => cc: {
                    try self.asmMemoryImmediate(
                        .{ ._, .@"test" },
                        try src_mcv.mem(self, .{ .size = .byte }),
                        .u(1),
                    );
                    break :cc .nz;
                },
            },
            registerAlias(regs[0], abi_size),
            registerAlias(regs[1], abi_size),
        );
        break :result .{ .register = regs[0] };
    };
    return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}

fn airSelect(self: *CodeGen, inst: Air.Inst.Index) !void {
    const pt = self.pt;
    const zcu = pt.zcu;
    const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
    const extra = self.air.extraData(Air.Bin, pl_op.payload).data;
    const ty = self.typeOfIndex(inst);
    const vec_len = ty.vectorLen(zcu);
    const elem_ty = ty.childType(zcu);
    const elem_abi_size: u32 = @intCast(elem_ty.abiSize(zcu));
    const abi_size: u32 = @intCast(ty.abiSize(zcu));
    const pred_ty = self.typeOf(pl_op.operand);

    const result = result: {
        const has_blend = self.hasFeature(.sse4_1);
        const has_avx = self.hasFeature(.avx);
        const need_xmm0 = has_blend and !has_avx;
        const pred_mcv = try self.resolveInst(pl_op.operand);
        const mask_reg = mask: {
            switch (pred_mcv) {
                .register => |pred_reg| switch (pred_reg.class()) {
                    .general_purpose => {},
                    .sse => if (elem_ty.toIntern() == .bool_type)
                        if (need_xmm0 and pred_reg.id() != comptime Register.xmm0.id()) {
                            try self.register_manager.getKnownReg(.xmm0, null);
                            try self.genSetReg(.xmm0, pred_ty, pred_mcv, .{});
                            break :mask .xmm0;
                        } else break :mask if (has_blend)
                            pred_reg
                        else
                            try self.copyToTmpRegister(pred_ty, pred_mcv)
                    else
                        return self.fail("TODO implement airSelect for {f}", .{ty.fmt(pt)}),
                    else => unreachable,
                },
                .register_mask => |pred_reg_mask| {
                    if (pred_reg_mask.info.scalar.bitSize(self.target) != 8 * elem_abi_size)
                        return self.fail("TODO implement airSelect for {f}", .{ty.fmt(pt)});

                    const mask_reg: Register = if (need_xmm0 and pred_reg_mask.reg.id() != comptime Register.xmm0.id()) mask_reg: {
                        try self.register_manager.getKnownReg(.xmm0, null);
                        try self.genSetReg(.xmm0, ty, .{ .register = pred_reg_mask.reg }, .{});
                        break :mask_reg .xmm0;
                    } else pred_reg_mask.reg;
                    const mask_alias = registerAlias(mask_reg, abi_size);
                    const mask_lock = self.register_manager.lockRegAssumeUnused(mask_reg);
                    defer self.register_manager.unlockReg(mask_lock);

                    const lhs_mcv = try self.resolveInst(extra.lhs);
                    const lhs_lock = switch (lhs_mcv) {
                        .register => |lhs_reg| self.register_manager.lockRegAssumeUnused(lhs_reg),
                        else => null,
                    };
                    defer if (lhs_lock) |lock| self.register_manager.unlockReg(lock);

                    const rhs_mcv = try self.resolveInst(extra.rhs);
                    const rhs_lock = switch (rhs_mcv) {
                        .register => |rhs_reg| self.register_manager.lockReg(rhs_reg),
                        else => null,
                    };
                    defer if (rhs_lock) |lock| self.register_manager.unlockReg(lock);

                    const order = has_blend != pred_reg_mask.info.inverted;
                    const reuse_mcv, const other_mcv = if (order)
                        .{ rhs_mcv, lhs_mcv }
                    else
                        .{ lhs_mcv, rhs_mcv };
                    const dst_mcv: MCValue = if (reuse_mcv.isRegister() and self.reuseOperand(
                        inst,
                        if (order) extra.rhs else extra.lhs,
                        @intFromBool(order),
                        reuse_mcv,
                    )) reuse_mcv else if (has_avx)
                        .{ .register = try self.register_manager.allocReg(inst, abi.RegisterClass.sse) }
                    else
                        try self.copyToRegisterWithInstTracking(inst, ty, reuse_mcv);
                    const dst_reg = dst_mcv.getReg().?;
                    const dst_alias = registerAlias(dst_reg, abi_size);
                    const dst_lock = self.register_manager.lockReg(dst_reg);
                    defer if (dst_lock) |lock| self.register_manager.unlockReg(lock);

                    const mir_tag = @as(?Mir.Inst.FixedTag, if ((pred_reg_mask.info.kind == .all and
                        elem_ty.toIntern() != .f32_type and elem_ty.toIntern() != .f64_type) or pred_reg_mask.info.scalar == .byte)
                        if (has_avx)
                            .{ .vp_b, .blendv }
                        else if (has_blend)
                            .{ .p_b, .blendv }
                        else if (pred_reg_mask.info.kind == .all)
                            .{ .p_, undefined }
                        else
                            null
                    else if ((pred_reg_mask.info.kind == .all and (elem_ty.toIntern() != .f64_type or !self.hasFeature(.sse2))) or
                        pred_reg_mask.info.scalar == .dword)
                        if (has_avx)
                            .{ .v_ps, .blendv }
                        else if (has_blend)
                            .{ ._ps, .blendv }
                        else if (pred_reg_mask.info.kind == .all)
                            .{ ._ps, undefined }
                        else
                            null
                    else if (pred_reg_mask.info.kind == .all or pred_reg_mask.info.scalar == .qword)
                        if (has_avx)
                            .{ .v_pd, .blendv }
                        else if (has_blend)
                            .{ ._pd, .blendv }
                        else if (pred_reg_mask.info.kind == .all)
                            .{ ._pd, undefined }
                        else
                            null
                    else
                        null) orelse return self.fail("TODO implement airSelect for {f}", .{ty.fmt(pt)});
                    if (has_avx) {
                        const rhs_alias = if (reuse_mcv.isRegister())
                            registerAlias(reuse_mcv.getReg().?, abi_size)
                        else rhs: {
                            try self.genSetReg(dst_reg, ty, reuse_mcv, .{});
                            break :rhs dst_alias;
                        };
                        if (other_mcv.isBase()) try self.asmRegisterRegisterMemoryRegister(
                            mir_tag,
                            dst_alias,
                            rhs_alias,
                            try other_mcv.mem(self, .{ .size = self.memSize(ty) }),
                            mask_alias,
                        ) else try self.asmRegisterRegisterRegisterRegister(
                            mir_tag,
                            dst_alias,
                            rhs_alias,
                            registerAlias(if (other_mcv.isRegister())
                                other_mcv.getReg().?
                            else
                                try self.copyToTmpRegister(ty, other_mcv), abi_size),
                            mask_alias,
                        );
                    } else if (has_blend) if (other_mcv.isBase()) try self.asmRegisterMemoryRegister(
                        mir_tag,
                        dst_alias,
                        try other_mcv.mem(self, .{ .size = self.memSize(ty) }),
                        mask_alias,
                    ) else try self.asmRegisterRegisterRegister(
                        mir_tag,
                        dst_alias,
                        registerAlias(if (other_mcv.isRegister())
                            other_mcv.getReg().?
                        else
                            try self.copyToTmpRegister(ty, other_mcv), abi_size),
                        mask_alias,
                    ) else {
                        try self.asmRegisterRegister(.{ mir_tag[0], .@"and" }, dst_alias, mask_alias);
                        if (other_mcv.isBase()) try self.asmRegisterMemory(
                            .{ mir_tag[0], .andn },
                            mask_alias,
                            try other_mcv.mem(self, .{ .size = .fromSize(abi_size) }),
                        ) else try self.asmRegisterRegister(
                            .{ mir_tag[0], .andn },
                            mask_alias,
                            registerAlias(if (other_mcv.isRegister())
                                other_mcv.getReg().?
                            else
                                try self.copyToTmpRegister(ty, other_mcv), abi_size),
                        );
                        try self.asmRegisterRegister(.{ mir_tag[0], .@"or" }, dst_alias, mask_alias);
                    }
                    break :result dst_mcv;
                },
                else => {},
            }
            const mask_reg: Register = if (need_xmm0) mask_reg: {
                try self.register_manager.getKnownReg(.xmm0, null);
                break :mask_reg .xmm0;
            } else try self.register_manager.allocReg(null, abi.RegisterClass.sse);
            const mask_alias = registerAlias(mask_reg, abi_size);
            const mask_lock = self.register_manager.lockRegAssumeUnused(mask_reg);
            defer self.register_manager.unlockReg(mask_lock);

            const pred_fits_in_elem = vec_len <= elem_abi_size;
            if (self.hasFeature(.avx2) and abi_size <= 32) {
                if (pred_mcv.isRegister()) broadcast: {
                    try self.asmRegisterRegister(
                        .{ .v_d, .mov },
                        mask_reg.to128(),
                        pred_mcv.getReg().?.to32(),
                    );
                    if (pred_fits_in_elem and vec_len > 1) try self.asmRegisterRegister(
                        .{ switch (elem_abi_size) {
                            1 => .vp_b,
                            2 => .vp_w,
                            3...4 => .vp_d,
                            5...8 => .vp_q,
                            9...16 => {
                                try self.asmRegisterRegisterRegisterImmediate(
                                    .{ .v_f128, .insert },
                                    mask_alias,
                                    mask_alias,
                                    mask_reg.to128(),
                                    .u(1),
                                );
                                break :broadcast;
                            },
                            17...32 => break :broadcast,
                            else => unreachable,
                        }, .broadcast },
                        mask_alias,
                        mask_reg.to128(),
                    );
                } else try self.asmRegisterMemory(
                    .{ switch (vec_len) {
                        1...8 => .vp_b,
                        9...16 => .vp_w,
                        17...32 => .vp_d,
                        else => unreachable,
                    }, .broadcast },
                    mask_alias,
                    if (pred_mcv.isBase()) try pred_mcv.mem(self, .{ .size = .byte }) else .{
                        .base = .{ .reg = (try self.copyToTmpRegister(
                            .usize,
                            pred_mcv.address(),
                        )).to64() },
                        .mod = .{ .rm = .{ .size = .byte } },
                    },
                );
            } else if (abi_size <= 16) broadcast: {
                try self.asmRegisterRegister(
                    .{ if (has_avx) .v_d else ._d, .mov },
                    mask_alias,
                    (if (pred_mcv.isRegister())
                        pred_mcv.getReg().?
                    else
                        try self.copyToTmpRegister(pred_ty, pred_mcv.address())).to32(),
                );
                if (!pred_fits_in_elem or vec_len == 1) break :broadcast;
                if (elem_abi_size <= 1) {
                    if (has_avx) try self.asmRegisterRegisterRegister(
                        .{ .vp_, .unpcklbw },
                        mask_alias,
                        mask_alias,
                        mask_alias,
                    ) else try self.asmRegisterRegister(
                        .{ .p_, .unpcklbw },
                        mask_alias,
                        mask_alias,
                    );
                    if (abi_size <= 2) break :broadcast;
                }
                if (elem_abi_size <= 2) {
                    try self.asmRegisterRegisterImmediate(
                        .{ if (has_avx) .vp_w else .p_w, .shufl },
                        mask_alias,
                        mask_alias,
                        .u(0b00_00_00_00),
                    );
                    if (abi_size <= 8) break :broadcast;
                }
                try self.asmRegisterRegisterImmediate(
                    .{ if (has_avx) .vp_d else .p_d, .shuf },
                    mask_alias,
                    mask_alias,
                    .u(switch (elem_abi_size) {
                        1...2, 5...8 => 0b01_00_01_00,
                        3...4 => 0b00_00_00_00,
                        else => unreachable,
                    }),
                );
            } else return self.fail("TODO implement airSelect for {f}", .{ty.fmt(pt)});
            const elem_bits: u16 = @intCast(elem_abi_size * 8);
            if (!pred_fits_in_elem) if (self.hasFeature(.ssse3)) {
                const mask_len = elem_abi_size * vec_len;
                const mask_ty = try pt.vectorType(.{
                    .len = mask_len,
                    .child = .u8_type,
                });
                var mask_elems_buf: [32]u8 = undefined;
                const mask_elems = mask_elems_buf[0..mask_len];
                for (mask_elems, 0..) |*elem, bit| elem.* = @intCast(bit / elem_bits);
                const mask_mcv = try self.lowerValue(.fromInterned(try pt.intern(.{ .aggregate = .{
                    .ty = mask_ty.toIntern(),
                    .storage = .{ .bytes = try zcu.intern_pool.getOrPutString(zcu.gpa, pt.tid, mask_elems, .maybe_embedded_nulls) },
                } })));
                const mask_mem: Memory = .{
                    .base = .{ .reg = try self.copyToTmpRegister(.usize, mask_mcv.address()) },
                    .mod = .{ .rm = .{ .size = self.memSize(ty) } },
                };
                if (has_avx) try self.asmRegisterRegisterMemory(
                    .{ .vp_b, .shuf },
                    mask_alias,
                    mask_alias,
                    mask_mem,
                ) else try self.asmRegisterMemory(
                    .{ .p_b, .shuf },
                    mask_alias,
                    mask_mem,
                );
            } else return self.fail("TODO implement airSelect for {f}", .{ty.fmt(pt)});
            {
                const mask_elem_ty = try pt.intType(.unsigned, elem_bits);
                const mask_ty = try pt.vectorType(.{ .len = vec_len, .child = mask_elem_ty.toIntern() });
                var mask_elems_buf: [32]InternPool.Index = undefined;
                const mask_elems = mask_elems_buf[0..vec_len];
                for (mask_elems, 0..) |*elem, bit| elem.* = (try pt.intValue(
                    mask_elem_ty,
                    @as(u8, 1) << @truncate(bit),
                )).toIntern();
                const mask_mcv = try self.lowerValue(try pt.aggregateValue(mask_ty, mask_elems));
                const mask_mem: Memory = .{
                    .base = .{ .reg = try self.copyToTmpRegister(.usize, mask_mcv.address()) },
                    .mod = .{ .rm = .{ .size = self.memSize(ty) } },
                };
                if (has_avx) {
                    try self.asmRegisterRegisterMemory(
                        .{ .vp_, .@"and" },
                        mask_alias,
                        mask_alias,
                        mask_mem,
                    );
                    try self.asmRegisterRegisterMemory(
                        .{ switch (elem_abi_size) {
                            else => unreachable,
                            1 => .vp_b,
                            2 => .vp_w,
                            4 => .vp_d,
                            8 => .vp_q,
                        }, .cmpeq },
                        mask_alias,
                        mask_alias,
                        mask_mem,
                    );
                } else {
                    try self.asmRegisterMemory(
                        .{ .p_, .@"and" },
                        mask_alias,
                        mask_mem,
                    );
                    try self.asmRegisterMemory(
                        .{ switch (elem_abi_size) {
                            else => unreachable,
                            1 => .p_b,
                            2 => .p_w,
                            4 => .p_d,
                            8 => if (has_blend) .p_q else unreachable,
                        }, .cmpeq },
                        mask_alias,
                        mask_mem,
                    );
                }
            }
            break :mask mask_reg;
        };
        const mask_alias = registerAlias(mask_reg, abi_size);
        const mask_lock = self.register_manager.lockRegAssumeUnused(mask_reg);
        defer self.register_manager.unlockReg(mask_lock);

        const lhs_mcv = try self.resolveInst(extra.lhs);
        const lhs_lock = switch (lhs_mcv) {
            .register => |lhs_reg| self.register_manager.lockRegAssumeUnused(lhs_reg),
            else => null,
        };
        defer if (lhs_lock) |lock| self.register_manager.unlockReg(lock);

        const rhs_mcv = try self.resolveInst(extra.rhs);
        const rhs_lock = switch (rhs_mcv) {
            .register => |rhs_reg| self.register_manager.lockReg(rhs_reg),
            else => null,
        };
        defer if (rhs_lock) |lock| self.register_manager.unlockReg(lock);

        const reuse_mcv = if (has_blend) rhs_mcv else lhs_mcv;
        const dst_mcv: MCValue = if (reuse_mcv.isRegister() and self.reuseOperand(
            inst,
            if (has_blend) extra.rhs else extra.lhs,
            @intFromBool(has_blend),
            reuse_mcv,
        )) reuse_mcv else if (has_avx)
            .{ .register = try self.register_manager.allocReg(inst, abi.RegisterClass.sse) }
        else
            try self.copyToRegisterWithInstTracking(inst, ty, reuse_mcv);
        const dst_reg = dst_mcv.getReg().?;
        const dst_alias = registerAlias(dst_reg, abi_size);
        const dst_lock = self.register_manager.lockReg(dst_reg);
        defer if (dst_lock) |lock| self.register_manager.unlockReg(lock);

        const mir_tag = @as(?Mir.Inst.FixedTag, switch (elem_ty.zigTypeTag(zcu)) {
            else => null,
            .int => switch (abi_size) {
                0 => unreachable,
                1...16 => if (has_avx)
                    .{ .vp_b, .blendv }
                else if (has_blend)
                    .{ .p_b, .blendv }
                else
                    .{ .p_, undefined },
                17...32 => if (self.hasFeature(.avx2))
                    .{ .vp_b, .blendv }
                else
                    null,
                else => null,
            },
            .float => switch (elem_ty.floatBits(self.target)) {
                else => unreachable,
                16, 80, 128 => null,
                32 => switch (vec_len) {
                    0 => unreachable,
                    1...4 => if (has_avx) .{ .v_ps, .blendv } else .{ ._ps, .blendv },
                    5...8 => if (has_avx) .{ .v_ps, .blendv } else null,
                    else => null,
                },
                64 => switch (vec_len) {
                    0 => unreachable,
                    1...2 => if (has_avx) .{ .v_pd, .blendv } else .{ ._pd, .blendv },
                    3...4 => if (has_avx) .{ .v_pd, .blendv } else null,
                    else => null,
                },
            },
        }) orelse return self.fail("TODO implement airSelect for {f}", .{ty.fmt(pt)});
        if (has_avx) {
            const rhs_alias = if (rhs_mcv.isRegister())
                registerAlias(rhs_mcv.getReg().?, abi_size)
            else rhs: {
                try self.genSetReg(dst_reg, ty, rhs_mcv, .{});
                break :rhs dst_alias;
            };
            if (lhs_mcv.isBase()) try self.asmRegisterRegisterMemoryRegister(
                mir_tag,
                dst_alias,
                rhs_alias,
                try lhs_mcv.mem(self, .{ .size = self.memSize(ty) }),
                mask_alias,
            ) else try self.asmRegisterRegisterRegisterRegister(
                mir_tag,
                dst_alias,
                rhs_alias,
                registerAlias(if (lhs_mcv.isRegister())
                    lhs_mcv.getReg().?
                else
                    try self.copyToTmpRegister(ty, lhs_mcv), abi_size),
                mask_alias,
            );
        } else if (has_blend) if (lhs_mcv.isBase()) try self.asmRegisterMemoryRegister(
            mir_tag,
            dst_alias,
            try lhs_mcv.mem(self, .{ .size = self.memSize(ty) }),
            mask_alias,
        ) else try self.asmRegisterRegisterRegister(
            mir_tag,
            dst_alias,
            registerAlias(if (lhs_mcv.isRegister())
                lhs_mcv.getReg().?
            else
                try self.copyToTmpRegister(ty, lhs_mcv), abi_size),
            mask_alias,
        ) else {
            try self.asmRegisterRegister(.{ mir_tag[0], .@"and" }, dst_alias, mask_alias);
            if (rhs_mcv.isBase()) try self.asmRegisterMemory(
                .{ mir_tag[0], .andn },
                mask_alias,
                try rhs_mcv.mem(self, .{ .size = .fromSize(abi_size) }),
            ) else try self.asmRegisterRegister(
                .{ mir_tag[0], .andn },
                mask_alias,
                registerAlias(if (rhs_mcv.isRegister())
                    rhs_mcv.getReg().?
                else
                    try self.copyToTmpRegister(ty, rhs_mcv), abi_size),
            );
            try self.asmRegisterRegister(.{ mir_tag[0], .@"or" }, dst_alias, mask_alias);
        }
        break :result dst_mcv;
    };
    return self.finishAir(inst, result, .{ pl_op.operand, extra.lhs, extra.rhs });
}

fn airAggregateInitBoolVec(self: *CodeGen, inst: Air.Inst.Index) !void {
    const pt = self.pt;
    const zcu = pt.zcu;
    const result_ty = self.typeOfIndex(inst);
    const len: usize = @intCast(result_ty.arrayLen(zcu));
    const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
    const elements: []const Air.Inst.Ref = @ptrCast(self.air.extra.items[ty_pl.payload..][0..len]);

    assert(result_ty.zigTypeTag(zcu) == .vector);
    assert(result_ty.childType(zcu).toIntern() == .bool_type);

    const result_size = result_ty.abiSize(zcu);
    if (result_size > 8) return self.fail("TODO airAggregateInitBoolVec over 8 bytes", .{});

    const dst_reg = try self.register_manager.allocReg(inst, abi.RegisterClass.gp);

    {
        const dst_lock = self.register_manager.lockRegAssumeUnused(dst_reg);
        defer self.register_manager.unlockReg(dst_lock);

        try self.spillEflagsIfOccupied();
        try self.asmRegisterRegister(
            .{ ._, .xor },
            registerAlias(dst_reg, @min(result_size, 4)),
            registerAlias(dst_reg, @min(result_size, 4)),
        );

        for (elements, 0..) |elem, elem_i| {
            const elem_reg = try self.copyToTmpRegister(.bool, .{ .air_ref = elem });
            const elem_lock = self.register_manager.lockRegAssumeUnused(elem_reg);
            defer self.register_manager.unlockReg(elem_lock);

            try self.asmRegisterImmediate(
                .{ ._, .@"and" },
                registerAlias(elem_reg, @min(result_size, 4)),
                .u(1),
            );
            if (elem_i > 0) try self.asmRegisterImmediate(
                .{ ._l, .sh },
                registerAlias(elem_reg, @intCast(result_size)),
                .u(@intCast(elem_i)),
            );
            try self.asmRegisterRegister(
                .{ ._, .@"or" },
                registerAlias(dst_reg, @intCast(result_size)),
                registerAlias(elem_reg, @intCast(result_size)),
            );
        }
    }

    const result: MCValue = .{ .register = dst_reg };

    if (elements.len <= Air.Liveness.bpi - 1) {
        var buf: [Air.Liveness.bpi - 1]Air.Inst.Ref = @splat(.none);
        @memcpy(buf[0..elements.len], elements);
        return self.finishAir(inst, result, buf);
    }
    var bt = self.liveness.iterateBigTomb(inst);
    for (elements) |elem| try self.feed(&bt, elem);
    return self.finishAirResult(inst, result);
}

fn airVaStart(self: *CodeGen, inst: Air.Inst.Index) !void {
    const pt = self.pt;
    const zcu = pt.zcu;
    const va_list_ty = self.air.instructions.items(.data)[@intFromEnum(inst)].ty;
    const ptr_anyopaque_ty = try pt.singleMutPtrType(.anyopaque);

    const result: MCValue = switch (self.fn_type.fnCallingConvention(zcu)) {
        .x86_64_sysv => result: {
            const info = self.va_info.sysv;
            const dst_fi = try self.allocFrameIndex(.initSpill(va_list_ty, zcu));
            var field_off: u31 = 0;
            // gp_offset: c_uint,
            try self.genSetMem(
                .{ .frame = dst_fi },
                field_off,
                .c_uint,
                .{ .immediate = info.gp_count * 8 },
                .{},
            );
            field_off += @intCast(Type.c_uint.abiSize(zcu));
            // fp_offset: c_uint,
            try self.genSetMem(
                .{ .frame = dst_fi },
                field_off,
                .c_uint,
                .{ .immediate = abi.SysV.c_abi_int_param_regs.len * 8 + info.fp_count * 16 },
                .{},
            );
            field_off += @intCast(Type.c_uint.abiSize(zcu));
            // overflow_arg_area: *anyopaque,
            try self.genSetMem(
                .{ .frame = dst_fi },
                field_off,
                ptr_anyopaque_ty,
                .{ .lea_frame = info.overflow_arg_area },
                .{},
            );
            field_off += @intCast(ptr_anyopaque_ty.abiSize(zcu));
            // reg_save_area: *anyopaque,
            try self.genSetMem(
                .{ .frame = dst_fi },
                field_off,
                ptr_anyopaque_ty,
                .{ .lea_frame = info.reg_save_area },
                .{},
            );
            field_off += @intCast(ptr_anyopaque_ty.abiSize(zcu));
            break :result .{ .load_frame = .{ .index = dst_fi } };
        },
        .x86_64_win => return self.fail("TODO implement c_va_start for Win64", .{}),
        else => |cc| return self.fail("{s} does not support var args", .{@tagName(cc)}),
    };
    return self.finishAir(inst, result, .{ .none, .none, .none });
}

fn airVaArg(self: *CodeGen, inst: Air.Inst.Index) !void {
    const pt = self.pt;
    const zcu = pt.zcu;
    const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
    const ty = self.typeOfIndex(inst);
    const promote_ty = self.promoteVarArg(ty);
    const ptr_anyopaque_ty = try pt.singleMutPtrType(.anyopaque);
    const unused = self.liveness.isUnused(inst);

    const result: MCValue = switch (self.fn_type.fnCallingConvention(zcu)) {
        .x86_64_sysv => result: {
            try self.spillEflagsIfOccupied();

            const tmp_regs =
                try self.register_manager.allocRegs(2, @splat(null), abi.RegisterClass.gp);
            const offset_reg = tmp_regs[0].to32();
            const addr_reg = tmp_regs[1].to64();
            const tmp_locks = self.register_manager.lockRegsAssumeUnused(2, tmp_regs);
            defer for (tmp_locks) |lock| self.register_manager.unlockReg(lock);

            const promote_mcv = try self.allocTempRegOrMem(promote_ty, true);
            const promote_lock = switch (promote_mcv) {
                .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
                else => null,
            };
            defer if (promote_lock) |lock| self.register_manager.unlockReg(lock);

            const ptr_arg_list_reg =
                try self.copyToTmpRegister(self.typeOf(ty_op.operand), .{ .air_ref = ty_op.operand });
            const ptr_arg_list_lock = self.register_manager.lockRegAssumeUnused(ptr_arg_list_reg);
            defer self.register_manager.unlockReg(ptr_arg_list_lock);

            const gp_offset: MCValue = .{ .indirect = .{ .reg = ptr_arg_list_reg, .off = 0 } };
            const fp_offset: MCValue = .{ .indirect = .{ .reg = ptr_arg_list_reg, .off = 4 } };
            const overflow_arg_area: MCValue = .{ .indirect = .{ .reg = ptr_arg_list_reg, .off = 8 } };
            const reg_save_area: MCValue = .{ .indirect = .{ .reg = ptr_arg_list_reg, .off = 16 } };

            const classes = std.mem.sliceTo(&abi.classifySystemV(promote_ty, zcu, self.target, .arg), .none);
            switch (classes[0]) {
                .integer => {
                    assert(classes.len == 1);

                    try self.genSetReg(offset_reg, .c_uint, gp_offset, .{});
                    try self.asmRegisterImmediate(.{ ._, .cmp }, offset_reg, .u(
                        abi.SysV.c_abi_int_param_regs.len * 8,
                    ));
                    const mem_reloc = try self.asmJccReloc(.ae, undefined);

                    try self.genSetReg(addr_reg, ptr_anyopaque_ty, reg_save_area, .{});
                    if (!unused) try self.asmRegisterMemory(.{ ._, .lea }, addr_reg, .{
                        .base = .{ .reg = addr_reg },
                        .mod = .{ .rm = .{ .index = offset_reg.to64() } },
                    });
                    try self.asmRegisterMemory(.{ ._, .lea }, offset_reg, .{
                        .base = .{ .reg = offset_reg.to64() },
                        .mod = .{ .rm = .{ .disp = 8 } },
                    });
                    try self.genCopy(.c_uint, gp_offset, .{ .register = offset_reg }, .{});
                    const done_reloc = try self.asmJmpReloc(undefined);

                    self.performReloc(mem_reloc);
                    try self.genSetReg(addr_reg, ptr_anyopaque_ty, overflow_arg_area, .{});
                    try self.asmRegisterMemory(.{ ._, .lea }, offset_reg.to64(), .{
                        .base = .{ .reg = addr_reg },
                        .mod = .{ .rm = .{ .disp = @intCast(@max(promote_ty.abiSize(zcu), 8)) } },
                    });
                    try self.genCopy(
                        ptr_anyopaque_ty,
                        overflow_arg_area,
                        .{ .register = offset_reg.to64() },
                        .{},
                    );

                    self.performReloc(done_reloc);
                    if (!unused) try self.genCopy(promote_ty, promote_mcv, .{
                        .indirect = .{ .reg = addr_reg },
                    }, .{});
                },
                .sse => {
                    assert(classes.len == 1);

                    try self.genSetReg(offset_reg, .c_uint, fp_offset, .{});
                    try self.asmRegisterImmediate(.{ ._, .cmp }, offset_reg, .u(
                        abi.SysV.c_abi_int_param_regs.len * 8 + abi.SysV.c_abi_sse_param_regs.len * 16,
                    ));
                    const mem_reloc = try self.asmJccReloc(.ae, undefined);

                    try self.genSetReg(addr_reg, ptr_anyopaque_ty, reg_save_area, .{});
                    if (!unused) try self.asmRegisterMemory(.{ ._, .lea }, addr_reg, .{
                        .base = .{ .reg = addr_reg },
                        .mod = .{ .rm = .{ .index = offset_reg.to64() } },
                    });
                    try self.asmRegisterMemory(.{ ._, .lea }, offset_reg, .{
                        .base = .{ .reg = offset_reg.to64() },
                        .mod = .{ .rm = .{ .disp = 16 } },
                    });
                    try self.genCopy(.c_uint, fp_offset, .{ .register = offset_reg }, .{});
                    const done_reloc = try self.asmJmpReloc(undefined);

                    self.performReloc(mem_reloc);
                    try self.genSetReg(addr_reg, ptr_anyopaque_ty, overflow_arg_area, .{});
                    try self.asmRegisterMemory(.{ ._, .lea }, offset_reg.to64(), .{
                        .base = .{ .reg = addr_reg },
                        .mod = .{ .rm = .{ .disp = @intCast(@max(promote_ty.abiSize(zcu), 8)) } },
                    });
                    try self.genCopy(
                        ptr_anyopaque_ty,
                        overflow_arg_area,
                        .{ .register = offset_reg.to64() },
                        .{},
                    );

                    self.performReloc(done_reloc);
                    if (!unused) try self.genCopy(promote_ty, promote_mcv, .{
                        .indirect = .{ .reg = addr_reg },
                    }, .{});
                },
                .memory => {
                    assert(classes.len == 1);
                    unreachable;
                },
                else => return self.fail("TODO implement c_va_arg for {f} on SysV", .{promote_ty.fmt(pt)}),
            }

            if (unused) break :result .unreach;
            if (ty.toIntern() == promote_ty.toIntern()) break :result promote_mcv;

            if (!promote_ty.isRuntimeFloat()) {
                const dst_mcv = try self.allocRegOrMem(inst, true);
                try self.genCopy(ty, dst_mcv, promote_mcv, .{});
                break :result dst_mcv;
            }

            assert(ty.toIntern() == .f32_type and promote_ty.toIntern() == .f64_type);
            const dst_mcv = if (promote_mcv.isRegister())
                promote_mcv
            else
                try self.copyToRegisterWithInstTracking(inst, ty, promote_mcv);
            const dst_reg = dst_mcv.getReg().?.to128();
            const dst_lock = self.register_manager.lockReg(dst_reg);
            defer if (dst_lock) |lock| self.register_manager.unlockReg(lock);

            if (self.hasFeature(.avx)) if (promote_mcv.isBase()) try self.asmRegisterRegisterMemory(
                .{ .v_ss, .cvtsd2 },
                dst_reg,
                dst_reg,
                try promote_mcv.mem(self, .{ .size = .qword }),
            ) else try self.asmRegisterRegisterRegister(
                .{ .v_ss, .cvtsd2 },
                dst_reg,
                dst_reg,
                (if (promote_mcv.isRegister())
                    promote_mcv.getReg().?
                else
                    try self.copyToTmpRegister(promote_ty, promote_mcv)).to128(),
            ) else if (promote_mcv.isBase()) try self.asmRegisterMemory(
                .{ ._ss, .cvtsd2 },
                dst_reg,
                try promote_mcv.mem(self, .{ .size = .qword }),
            ) else try self.asmRegisterRegister(
                .{ ._ss, .cvtsd2 },
                dst_reg,
                (if (promote_mcv.isRegister())
                    promote_mcv.getReg().?
                else
                    try self.copyToTmpRegister(promote_ty, promote_mcv)).to128(),
            );
            break :result promote_mcv;
        },
        .x86_64_win => return self.fail("TODO implement c_va_arg for Win64", .{}),
        else => |cc| return self.fail("{s} does not support var args", .{@tagName(cc)}),
    };
    return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}

fn airVaCopy(self: *CodeGen, inst: Air.Inst.Index) !void {
    const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
    const ptr_va_list_ty = self.typeOf(ty_op.operand);

    const dst_mcv = try self.allocRegOrMem(inst, true);
    try self.load(dst_mcv, ptr_va_list_ty, .{ .air_ref = ty_op.operand });
    return self.finishAir(inst, dst_mcv, .{ ty_op.operand, .none, .none });
}

fn airVaEnd(self: *CodeGen, inst: Air.Inst.Index) !void {
    const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
    return self.finishAir(inst, .unreach, .{ un_op, .none, .none });
}

fn resolveInst(self: *CodeGen, ref: Air.Inst.Ref) InnerError!MCValue {
    const zcu = self.pt.zcu;
    const ty = self.typeOf(ref);

    // If the type has no codegen bits, no need to store it.
    if (!ty.hasRuntimeBitsIgnoreComptime(zcu)) return .none;

    const mcv: MCValue = if (ref.toIndex()) |inst| mcv: {
        break :mcv self.inst_tracking.getPtr(inst).?.short;
    } else mcv: {
        break :mcv try self.lowerValue(.fromInterned(ref.toInterned().?));
    };

    switch (mcv) {
        .none, .unreach, .dead => unreachable,
        else => return mcv,
    }
}

fn getResolvedInstValue(self: *CodeGen, inst: Air.Inst.Index) *InstTracking {
    const tracking = self.inst_tracking.getPtr(inst).?;
    return switch (tracking.short) {
        .none, .unreach, .dead => unreachable,
        else => tracking,
    };
}

fn lowerValue(cg: *CodeGen, val: Value) Allocator.Error!MCValue {
    return switch (try codegen.lowerValue(cg.pt, val, cg.target)) {
        .none => .none,
        .undef => .undef,
        .immediate => |imm| .{ .immediate = imm },
        .lea_nav => |nav| .{ .lea_nav = nav },
        .lea_uav => |uav| .{ .lea_uav = uav },
        .load_uav => |uav| .{ .load_uav = uav },
    };
}

const CallMCValues = struct {
    args: []MCValue,
    air_arg_count: u32,
    return_value: InstTracking,
    stack_byte_count: u31,
    stack_align: InternPool.Alignment,
    gp_count: u32,
    fp_count: u32,
    err_ret_trace_reg: Register,

    fn deinit(self: *CallMCValues, func: *CodeGen) void {
        func.gpa.free(self.args);
        self.* = undefined;
    }
};

const win64_shadow_space = 8 * 4;

/// Caller must call `CallMCValues.deinit`.
fn resolveCallingConventionValues(
    cg: *CodeGen,
    fn_info: InternPool.Key.FuncType,
    var_args: []const Type,
    stack_frame_base: FrameIndex,
) !CallMCValues {
    const pt = cg.pt;
    const zcu = pt.zcu;
    const ip = &zcu.intern_pool;
    const cc = fn_info.cc;

    const ExpectedContents = extern struct {
        param_types: [32][@sizeOf(Type)]u8 align(@alignOf(Type)),
    };
    var stack align(@max(@alignOf(ExpectedContents), @alignOf(std.heap.StackFallbackAllocator(0)))) =
        std.heap.stackFallback(@sizeOf(ExpectedContents), cg.gpa);
    const allocator = stack.get();

    const param_types = try allocator.alloc(Type, fn_info.param_types.len + var_args.len);
    defer allocator.free(param_types);

    for (param_types[0..fn_info.param_types.len], fn_info.param_types.get(ip)) |*param_ty, arg_ty|
        param_ty.* = .fromInterned(arg_ty);
    for (param_types[fn_info.param_types.len..], var_args) |*param_ty, arg_ty|
        param_ty.* = cg.promoteVarArg(arg_ty);

    var result: CallMCValues = .{
        .args = try cg.gpa.alloc(MCValue, param_types.len),
        .air_arg_count = 0,
        // These undefined values must be populated before returning from this function.
        .return_value = undefined,
        .stack_byte_count = 0,
        .stack_align = undefined,
        .gp_count = 0,
        .fp_count = 0,
        .err_ret_trace_reg = .none,
    };
    errdefer cg.gpa.free(result.args);

    const ret_ty: Type = .fromInterned(fn_info.return_type);
    switch (cc) {
        .naked => {
            assert(result.args.len == 0);
            result.return_value = .init(.unreach);
            result.stack_align = switch (cg.target.cpu.arch) {
                else => unreachable,
                .x86 => .@"4",
                .x86_64 => .@"8",
            };
        },
        .x86_64_sysv, .x86_64_win => |cc_opts| {
            const param_gpr = abi.getCAbiIntParamRegs(cc);
            var param_gpr_index: u32 = 0;
            const param_sse = abi.getCAbiSseParamRegs(cc, cg.target);
            var param_sse_index: u32 = 0;

            result.stack_align = .fromByteUnits(cc_opts.incoming_stack_alignment orelse 16);

            switch (cc) {
                .x86_64_sysv => {},
                .x86_64_win => result.stack_byte_count += @intCast(win64_shadow_space),
                else => unreachable,
            }

            // Return values
            if (ret_ty.isNoReturn(zcu)) {
                result.return_value = .init(.unreach);
            } else if (!ret_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
                // TODO: is this even possible for C calling convention?
                result.return_value = .init(.none);
            } else {
                var ret_tracking: [4]InstTracking = undefined;
                var ret_tracking_len: u32 = 0;
                var ret_gpr = abi.getCAbiIntReturnRegs(cc);
                var ret_sse = abi.getCAbiSseReturnRegs(cc);
                var ret_x87 = abi.getCAbiX87ReturnRegs(cc);

                const classes = switch (cc) {
                    .x86_64_sysv => std.mem.sliceTo(&abi.classifySystemV(ret_ty, zcu, cg.target, .ret), .none),
                    .x86_64_win => &.{abi.classifyWindows(ret_ty, zcu, cg.target, .ret)},
                    else => unreachable,
                };
                for (classes) |class| switch (class) {
                    .integer => {
                        ret_tracking[ret_tracking_len] = .init(.{ .register = registerAlias(
                            ret_gpr[0],
                            @intCast(@min(ret_ty.abiSize(zcu), 8)),
                        ) });
                        ret_tracking_len += 1;
                        ret_gpr = ret_gpr[1..];
                    },
                    .sse, .float, .float_combine, .win_i128 => {
                        const abi_size: u32 = @intCast(ret_ty.abiSize(zcu));
                        const reg_size = @min(abi_size, cg.vectorSize(.float));
                        var byte_offset: u32 = 0;
                        while (byte_offset < abi_size) : (byte_offset += reg_size) {
                            const ret_sse_reg = registerAlias(ret_sse[0], reg_size);
                            ret_sse = ret_sse[1..];

                            ret_tracking[ret_tracking_len] = .init(.{ .register = ret_sse_reg });
                            ret_tracking_len += 1;
                        }
                    },
                    .sseup => assert(ret_tracking[ret_tracking_len - 1].short.register.isClass(.sse)),
                    .x87 => {
                        ret_tracking[ret_tracking_len] = .init(.{ .register = ret_x87[0] });
                        ret_tracking_len += 1;
                        ret_x87 = ret_x87[1..];
                    },
                    .x87up => assert(ret_tracking[ret_tracking_len - 1].short.register.isClass(.x87)),
                    .memory, .integer_per_element => {
                        ret_tracking[ret_tracking_len] = .{
                            .short = .{ .indirect = .{ .reg = ret_gpr[0].to64() } },
                            .long = .{ .indirect = .{ .reg = param_gpr[param_gpr_index].to64() } },
                        };
                        ret_tracking_len += 1;
                        ret_gpr = ret_gpr[1..];
                        param_gpr_index += 1;
                    },
                    .none => unreachable,
                };
                result.return_value = switch (ret_tracking_len) {
                    else => unreachable,
                    1 => ret_tracking[0],
                    2 => .init(.{ .register_pair = .{
                        ret_tracking[0].short.register,
                        ret_tracking[1].short.register,
                    } }),
                    3 => .init(.{ .register_triple = .{
                        ret_tracking[0].short.register,
                        ret_tracking[1].short.register,
                        ret_tracking[2].short.register,
                    } }),
                    4 => .init(.{ .register_quadruple = .{
                        ret_tracking[0].short.register,
                        ret_tracking[1].short.register,
                        ret_tracking[2].short.register,
                        ret_tracking[3].short.register,
                    } }),
                };
            }

            // Input params
            params: for (param_types, result.args) |ty, *arg| {
                assert(ty.hasRuntimeBitsIgnoreComptime(zcu));
                result.air_arg_count += 1;
                switch (cc) {
                    .x86_64_sysv => {},
                    .x86_64_win => {
                        param_gpr_index = @max(param_gpr_index, param_sse_index);
                        param_sse_index = param_gpr_index;
                    },
                    else => unreachable,
                }

                var arg_mcv: [4]MCValue = undefined;
                var arg_mcv_len: u32 = 0;

                const classes = switch (cc) {
                    .x86_64_sysv => std.mem.sliceTo(&abi.classifySystemV(ty, zcu, cg.target, .arg), .none),
                    .x86_64_win => &.{abi.classifyWindows(ty, zcu, cg.target, .arg)},
                    else => unreachable,
                };
                classes: for (classes) |class| switch (class) {
                    .integer => {
                        if (param_gpr_index >= param_gpr.len) break;
                        arg_mcv[arg_mcv_len] = .{
                            .register = registerAlias(param_gpr[param_gpr_index], @intCast(@min(ty.abiSize(zcu), 8))),
                        };
                        arg_mcv_len += 1;
                        param_gpr_index += 1;
                    },
                    .sse, .float, .float_combine => {
                        const abi_size: u32 = @intCast(ty.abiSize(zcu));
                        const reg_size = @min(abi_size, cg.vectorSize(.float));
                        var byte_offset: u32 = 0;
                        while (byte_offset < abi_size) : (byte_offset += reg_size) {
                            if (param_sse_index >= param_sse.len) break :classes;

                            const param_sse_reg = registerAlias(param_sse[param_sse_index], reg_size);
                            param_sse_index += 1;

                            arg_mcv[arg_mcv_len] = .{ .register = param_sse_reg };
                            arg_mcv_len += 1;
                        }
                    },
                    .sseup => assert(arg_mcv[arg_mcv_len - 1].register.isClass(.sse)),
                    .x87, .x87up, .memory, .win_i128 => switch (cc) {
                        .x86_64_sysv => switch (class) {
                            .x87, .x87up, .memory => break,
                            else => unreachable,
                        },
                        .x86_64_win => if (ty.abiSize(zcu) > 8) {
                            if (param_gpr_index < param_gpr.len) {
                                arg_mcv[arg_mcv_len] = .{ .indirect = .{ .reg = param_gpr[param_gpr_index].to64() } };
                                arg_mcv_len += 1;
                                param_gpr_index += 1;
                            } else {
                                assert(arg_mcv_len == 0);
                                const param_align = Type.usize.abiAlignment(zcu);
                                result.stack_byte_count = @intCast(param_align.forward(result.stack_byte_count));
                                result.stack_align = result.stack_align.max(param_align);
                                arg.* = .{ .indirect_load_frame = .{
                                    .index = stack_frame_base,
                                    .off = result.stack_byte_count,
                                } };
                                result.stack_byte_count += @intCast(Type.usize.abiSize(zcu));
                                continue :params;
                            }
                        } else break,
                        else => unreachable,
                    },
                    .none => unreachable,
                    .integer_per_element => {
                        const remaining_param_gpr_len: u3 = @intCast(param_gpr.len - param_gpr_index);
                        param_gpr_index = @intCast(param_gpr.len);

                        const frame_elem_align = 8;
                        const frame_elems_len = ty.vectorLen(zcu) - remaining_param_gpr_len;
                        const frame_elem_size = std.mem.alignForward(u64, ty.childType(zcu).abiSize(zcu), frame_elem_align);
                        const frame_size: u31 = @intCast(frame_elems_len * frame_elem_size);

                        result.stack_byte_count = std.mem.alignForward(u31, result.stack_byte_count, frame_elem_align);
                        arg_mcv[arg_mcv_len] = .{ .elementwise_args = .{
                            .regs = remaining_param_gpr_len,
                            .frame_off = @intCast(result.stack_byte_count),
                            .frame_index = stack_frame_base,
                        } };
                        arg_mcv_len += 1;
                        result.stack_byte_count += frame_size;
                    },
                } else {
                    arg.* = switch (arg_mcv_len) {
                        else => unreachable,
                        1 => arg_mcv[0],
                        2 => .{ .register_pair = .{
                            arg_mcv[0].register,
                            arg_mcv[1].register,
                        } },
                        3 => .{ .register_triple = .{
                            arg_mcv[0].register,
                            arg_mcv[1].register,
                            arg_mcv[2].register,
                        } },
                        4 => .{ .register_quadruple = .{
                            arg_mcv[0].register,
                            arg_mcv[1].register,
                            arg_mcv[2].register,
                            arg_mcv[3].register,
                        } },
                    };
                    continue;
                }

                const param_align = ty.abiAlignment(zcu).max(.@"8");
                result.stack_byte_count = @intCast(param_align.forward(result.stack_byte_count));
                result.stack_align = result.stack_align.max(param_align);
                arg.* = .{ .load_frame = .{
                    .index = stack_frame_base,
                    .off = result.stack_byte_count,
                } };
                result.stack_byte_count += @intCast(ty.abiSize(zcu));
            }
            assert(param_gpr_index <= 6);
            result.gp_count = param_gpr_index;
            assert(param_sse_index <= 16);
            result.fp_count = param_sse_index;
        },
        .auto => {
            result.stack_align = abi.zigcc.stack_align orelse .fromByteUnits(cg.vectorSize(.float));

            var param_gpr = abi.getCAbiIntParamRegs(cc);
            var param_x87 = abi.getCAbiX87ParamRegs(cc);
            var param_sse = abi.getCAbiSseParamRegs(cc, cg.target);

            if (zcu.comp.config.any_error_tracing) {
                result.err_ret_trace_reg = param_gpr[param_gpr.len - 1];
                param_gpr = param_gpr[0 .. param_gpr.len - 1];
            }

            // Return values
            result.return_value = if (ret_ty.isNoReturn(zcu))
                .init(.unreach)
            else if (!ret_ty.hasRuntimeBitsIgnoreComptime(zcu))
                .init(.none)
            else return_value: {
                const ret_gpr = abi.getCAbiIntReturnRegs(cc);
                const ret_size: u31 = @intCast(ret_ty.abiSize(zcu));
                if (abi.zigcc.return_in_regs) switch (cg.regClassForType(ret_ty)) {
                    .general_purpose, .gphi => if (ret_size <= @as(u4, switch (cg.target.cpu.arch) {
                        else => unreachable,
                        .x86 => 4,
                        .x86_64 => 8,
                    }))
                        break :return_value .init(.{ .register = registerAlias(ret_gpr[0], ret_size) })
                    else if (ret_gpr.len >= 2 and ret_ty.isSliceAtRuntime(zcu))
                        break :return_value .init(.{ .register_pair = ret_gpr[0..2].* }),
                    .segment, .mmx, .ip, .cr, .dr => unreachable,
                    .x87 => if (ret_size <= 16) break :return_value .init(.{ .register = .st0 }),
                    .sse => if (ret_size <= cg.vectorSize(.float)) break :return_value .init(.{
                        .register = registerAlias(abi.getCAbiSseReturnRegs(cc)[0], @max(ret_size, 16)),
                    }),
                };
                const ret_indirect_reg = param_gpr[0];
                param_gpr = param_gpr[1..];
                break :return_value .{
                    .short = .{ .indirect = .{ .reg = ret_gpr[0] } },
                    .long = .{ .indirect = .{ .reg = ret_indirect_reg } },
                };
            };

            // Input params
            for (param_types, result.args) |param_ty, *arg| {
                if (!param_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
                    arg.* = .none;
                    continue;
                }
                result.air_arg_count += 1;
                const param_size: u31 = @intCast(param_ty.abiSize(zcu));
                if (abi.zigcc.params_in_regs) switch (cg.regClassForType(param_ty)) {
                    .general_purpose, .gphi => if (param_gpr.len >= 1 and param_size <= @as(u4, switch (cg.target.cpu.arch) {
                        else => unreachable,
                        .x86 => 4,
                        .x86_64 => 8,
                    })) {
                        arg.* = .{ .register = registerAlias(param_gpr[0], param_size) };
                        param_gpr = param_gpr[1..];
                        continue;
                    } else if (param_gpr.len >= 2 and param_ty.isSliceAtRuntime(zcu)) {
                        arg.* = .{ .register_pair = param_gpr[0..2].* };
                        param_gpr = param_gpr[2..];
                        continue;
                    },
                    .segment, .mmx, .ip, .cr, .dr => unreachable,
                    .x87 => if (param_x87.len >= 1 and param_size <= 16) {
                        arg.* = .{ .register = param_x87[0] };
                        param_x87 = param_x87[1..];
                        continue;
                    },
                    .sse => if (param_sse.len >= 1 and param_size <= cg.vectorSize(.float)) {
                        arg.* = .{
                            .register = registerAlias(param_sse[0], @max(param_size, 16)),
                        };
                        param_sse = param_sse[1..];
                        continue;
                    },
                };
                const param_align = param_ty.abiAlignment(zcu);
                result.stack_byte_count = @intCast(param_align.forward(result.stack_byte_count));
                result.stack_align = result.stack_align.max(param_align);
                arg.* = .{ .load_frame = .{
                    .index = stack_frame_base,
                    .off = result.stack_byte_count,
                } };
                result.stack_byte_count += param_size;
            }
        },
        else => return cg.fail("TODO implement function parameters and return values for {} on x86_64", .{cc}),
    }

    result.stack_byte_count = @intCast(result.stack_align.forward(result.stack_byte_count));
    return result;
}

fn fail(cg: *CodeGen, comptime format: []const u8, args: anytype) error{ OutOfMemory, CodegenFail } {
    @branchHint(.cold);
    const zcu = cg.pt.zcu;
    return switch (cg.owner) {
        .nav_index => |i| zcu.codegenFail(i, format, args),
        .lazy_sym => |s| zcu.codegenFailType(s.ty, format, args),
    };
}

fn parseRegName(name: []const u8) ?Register {
    if (std.mem.startsWith(u8, name, "db")) return @enumFromInt(
        @intFromEnum(Register.dr0) + (std.fmt.parseInt(u4, name["db".len..], 0) catch return null),
    );
    return std.meta.stringToEnum(Register, name);
}

/// Returns register wide enough to hold at least `size_bytes`.
fn registerAlias(reg: Register, size_bytes: u32) Register {
    if (size_bytes == 0) unreachable; // should be comptime-known
    return switch (reg.class()) {
        .general_purpose => if (size_bytes <= 1)
            reg.to8()
        else if (size_bytes <= 2)
            reg.to16()
        else if (size_bytes <= 4)
            reg.to32()
        else if (size_bytes <= 8)
            reg.to64()
        else
            unreachable,
        .gphi => if (size_bytes <= 1)
            reg
        else if (size_bytes <= 2)
            reg.to16()
        else if (size_bytes <= 4)
            reg.to32()
        else if (size_bytes <= 8)
            reg.to64()
        else
            unreachable,
        .segment => if (size_bytes <= 2)
            reg
        else
            unreachable,
        .x87 => if (size_bytes >= 4 and size_bytes <= 16)
            reg
        else
            unreachable,
        .mmx => if (size_bytes <= 8)
            reg
        else
            unreachable,
        .sse => if (size_bytes <= 16)
            reg.to128()
        else if (size_bytes <= 32)
            reg.to256()
        else
            unreachable,
        .ip => if (size_bytes <= 2)
            .ip
        else if (size_bytes <= 4)
            .eip
        else if (size_bytes <= 8)
            .rip
        else
            unreachable,
        .cr => if (size_bytes <= 8)
            reg
        else
            unreachable,
        .dr => if (size_bytes <= 8)
            reg
        else
            unreachable,
    };
}

fn memSize(self: *CodeGen, ty: Type) Memory.Size {
    const zcu = self.pt.zcu;
    return if (self.floatBits(ty)) |float_bits|
        .fromBitSize(float_bits)
    else if (ty.isVector(zcu) and ty.vectorLen(zcu) == 1 and self.floatBits(ty.childType(zcu)) == 80)
        .tbyte
    else
        .fromSize(@intCast(ty.abiSize(zcu)));
}

fn splitType(self: *CodeGen, comptime parts_len: usize, ty: Type) ![parts_len]Type {
    const pt = self.pt;
    const zcu = pt.zcu;
    const ip = &zcu.intern_pool;
    var parts: [parts_len]Type = undefined;
    switch (ip.indexToKey(ty.toIntern())) {
        .vector_type => |vector_type| if (std.math.divExact(u32, vector_type.len, parts_len)) |vec_len| return .{
            try pt.vectorType(.{ .len = vec_len, .child = vector_type.child }),
        } ** parts_len else |err| switch (err) {
            error.DivisionByZero => unreachable,
            error.UnexpectedRemainder => {},
        },
        .tuple_type => |tuple_type| if (tuple_type.types.len == parts_len) {
            for (&parts, tuple_type.types.get(ip)) |*part, part_ty| part.* = .fromInterned(part_ty);
            return parts;
        },
        else => {},
    }
    const classes = std.mem.sliceTo(&abi.classifySystemV(ty, zcu, self.target, .other), .none);
    if (classes.len == parts_len) for (&parts, classes, 0..) |*part, class, part_i| {
        part.* = switch (class) {
            .integer => if (part_i < parts_len - 1)
                .u64
            else part: {
                const elem_size = ty.abiAlignment(zcu).minStrict(.@"8").toByteUnits().?;
                const elem_ty = try pt.intType(.unsigned, @intCast(elem_size * 8));
                break :part switch (@divExact(ty.abiSize(zcu) - part_i * 8, elem_size)) {
                    1 => elem_ty,
                    else => |array_len| try pt.arrayType(.{ .len = array_len, .child = elem_ty.toIntern() }),
                };
            },
            .float => .f32,
            .float_combine => try pt.arrayType(.{ .len = 2, .child = .f32_type }),
            .sse => .f64,
            else => break,
        };
    } else {
        var part_sizes: u64 = 0;
        for (parts) |part| part_sizes += part.abiSize(zcu);
        if (part_sizes == ty.abiSize(zcu)) return parts;
    };
    return self.fail("TODO implement splitType({d}, {f})", .{ parts_len, ty.fmt(pt) });
}

/// Truncates the value in the register in place.
/// Clobbers any remaining bits.
fn truncateRegister(self: *CodeGen, ty: Type, reg: Register) !void {
    const pt = self.pt;
    const zcu = pt.zcu;
    const int_info: InternPool.Key.IntType = if (ty.isAbiInt(zcu)) ty.intInfo(zcu) else .{
        .signedness = .unsigned,
        .bits = @intCast(ty.bitSize(zcu)),
    };
    const shift = std.math.cast(u6, 64 - int_info.bits % 64) orelse return;
    try self.spillEflagsIfOccupied();
    switch (int_info.signedness) {
        .signed => {
            try self.genShiftBinOpMir(.{ ._l, .sa }, .isize, .{ .register = reg }, .u8, .{ .immediate = shift });
            try self.genShiftBinOpMir(.{ ._r, .sa }, .isize, .{ .register = reg }, .u8, .{ .immediate = shift });
        },
        .unsigned => {
            const mask = ~@as(u64, 0) >> shift;
            if (int_info.bits <= 32) {
                try self.genBinOpMir(.{ ._, .@"and" }, .u32, .{ .register = reg }, .{ .immediate = mask });
            } else {
                const tmp_reg = try self.copyToTmpRegister(.usize, .{ .immediate = mask });
                try self.genBinOpMir(.{ ._, .@"and" }, .usize, .{ .register = reg }, .{ .register = tmp_reg });
            }
        },
    }
}

fn regBitSize(self: *CodeGen, ty: Type) u64 {
    const zcu = self.pt.zcu;
    const abi_size = ty.abiSize(zcu);
    return switch (ty.zigTypeTag(zcu)) {
        else => switch (abi_size) {
            1 => 8,
            2 => 16,
            3...4 => 32,
            5...8 => 64,
            else => unreachable,
        },
        .float => switch (abi_size) {
            1...16 => 128,
            17...32 => 256,
            else => unreachable,
        },
    };
}

fn regExtraBits(self: *CodeGen, ty: Type) u64 {
    return self.regBitSize(ty) - ty.bitSize(self.pt.zcu);
}

fn hasFeature(cg: *CodeGen, feature: std.Target.x86.Feature) bool {
    return switch (feature) {
        .@"64bit" => switch (cg.target.cpu.arch) {
            else => unreachable,
            .x86 => false,
            .x86_64 => true,
        },
        .false_deps_getmant,
        .false_deps_lzcnt_tzcnt,
        .false_deps_mulc,
        .false_deps_mullq,
        .false_deps_perm,
        .false_deps_popcnt,
        .false_deps_range,
        .slow_3ops_lea,
        .slow_incdec,
        .slow_lea,
        .slow_pmaddwd,
        .slow_pmulld,
        .slow_shld,
        .slow_two_mem_ops,
        .slow_unaligned_mem_16,
        .slow_unaligned_mem_32,
        => switch (cg.mod.optimize_mode) {
            .Debug, .ReleaseSafe, .ReleaseFast => null,
            .ReleaseSmall => false,
        },
        .fast_11bytenop,
        .fast_15bytenop,
        .fast_7bytenop,
        .fast_bextr,
        .fast_dpwssd,
        .fast_gather,
        .fast_hops,
        .fast_imm16,
        .fast_lzcnt,
        .fast_movbe,
        .fast_scalar_fsqrt,
        .fast_scalar_shift_masks,
        .fast_shld_rotate,
        .fast_variable_crosslane_shuffle,
        .fast_variable_perlane_shuffle,
        .fast_vector_fsqrt,
        .fast_vector_shift_masks,
        => switch (cg.mod.optimize_mode) {
            .Debug, .ReleaseSafe, .ReleaseFast => null,
            .ReleaseSmall => true,
        },
        .mmx => false,
        .sahf => switch (cg.target.cpu.arch) {
            else => unreachable,
            .x86 => true,
            .x86_64 => null,
        },
        else => null,
    } orelse cg.target.cpu.has(.x86, feature);
}

fn typeOf(self: *CodeGen, inst: Air.Inst.Ref) Type {
    const pt = self.pt;
    const zcu = pt.zcu;
    return self.air.typeOf(inst, &zcu.intern_pool);
}

fn typeOfIndex(self: *CodeGen, inst: Air.Inst.Index) Type {
    return Temp.typeOf(.{ .index = inst }, self);
}

fn promoteInt(self: *CodeGen, ty: Type) Type {
    const pt = self.pt;
    const zcu = pt.zcu;
    const int_info: InternPool.Key.IntType = switch (ty.toIntern()) {
        .bool_type => .{ .signedness = .unsigned, .bits = 1 },
        else => if (ty.isAbiInt(zcu)) ty.intInfo(zcu) else return ty,
    };
    for ([_]Type{
        .c_int,      .c_uint,
        .c_long,     .c_ulong,
        .c_longlong, .c_ulonglong,
    }) |promote_ty| {
        const promote_info = promote_ty.intInfo(zcu);
        if (int_info.signedness == .signed and promote_info.signedness == .unsigned) continue;
        if (int_info.bits + @intFromBool(int_info.signedness == .unsigned and
            promote_info.signedness == .signed) <= promote_info.bits) return promote_ty;
    }
    return ty;
}

fn promoteVarArg(self: *CodeGen, ty: Type) Type {
    if (!ty.isRuntimeFloat()) return self.promoteInt(ty);
    switch (ty.floatBits(self.target)) {
        32, 64 => return .f64,
        else => |float_bits| {
            assert(float_bits == self.target.cTypeBitSize(.longdouble));
            return .c_longdouble;
        },
    }
}

fn unalignedSize(cg: *CodeGen, ty: Type) u64 {
    const zcu = cg.pt.zcu;
    return switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
        .vector_type => |vector_type| switch (vector_type.child) {
            .bool_type => ty.abiSize(zcu),
            else => Type.fromInterned(vector_type.child).abiSize(zcu) * vector_type.len,
        },
        else => ty.abiSize(zcu),
    };
}

fn nonBoolScalarBitSize(cg: *CodeGen, ty: Type) u32 {
    const zcu = cg.pt.zcu;
    return switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
        .vector_type => |vector_type| switch (vector_type.child) {
            .bool_type => vector_type.len,
            else => @intCast(Type.fromInterned(vector_type.child).bitSize(zcu)),
        },
        else => @intCast(ty.bitSize(zcu)),
    };
}

fn intInfo(cg: *CodeGen, ty: Type) ?std.builtin.Type.Int {
    const zcu = cg.pt.zcu;
    const ip = &zcu.intern_pool;
    var ty_index = ty.ip_index;
    while (true) switch (ip.indexToKey(ty_index)) {
        .int_type => |int_type| return int_type,
        .ptr_type => |ptr_type| return switch (ptr_type.flags.size) {
            .one, .many, .c => .{ .signedness = .unsigned, .bits = cg.target.ptrBitWidth() },
            .slice => null,
        },
        .opt_type => |opt_child| return if (!Type.fromInterned(opt_child).hasRuntimeBitsIgnoreComptime(zcu))
            .{ .signedness = .unsigned, .bits = 1 }
        else switch (ip.indexToKey(opt_child)) {
            .ptr_type => |ptr_type| switch (ptr_type.flags.size) {
                .one, .many => switch (ptr_type.flags.is_allowzero) {
                    false => .{ .signedness = .unsigned, .bits = cg.target.ptrBitWidth() },
                    true => null,
                },
                .slice, .c => null,
            },
            else => null,
        },
        .error_union_type => |error_union_type| return if (!Type.fromInterned(error_union_type.payload_type)
            .hasRuntimeBitsIgnoreComptime(zcu)) .{ .signedness = .unsigned, .bits = zcu.errorSetBits() } else null,
        .simple_type => |simple_type| return switch (simple_type) {
            .bool => .{ .signedness = .unsigned, .bits = 1 },
            .anyerror => .{ .signedness = .unsigned, .bits = zcu.errorSetBits() },
            .isize => .{ .signedness = .signed, .bits = cg.target.ptrBitWidth() },
            .usize => .{ .signedness = .unsigned, .bits = cg.target.ptrBitWidth() },
            .c_char => .{ .signedness = cg.target.cCharSignedness(), .bits = cg.target.cTypeBitSize(.char) },
            .c_short => .{ .signedness = .signed, .bits = cg.target.cTypeBitSize(.short) },
            .c_ushort => .{ .signedness = .unsigned, .bits = cg.target.cTypeBitSize(.short) },
            .c_int => .{ .signedness = .signed, .bits = cg.target.cTypeBitSize(.int) },
            .c_uint => .{ .signedness = .unsigned, .bits = cg.target.cTypeBitSize(.int) },
            .c_long => .{ .signedness = .signed, .bits = cg.target.cTypeBitSize(.long) },
            .c_ulong => .{ .signedness = .unsigned, .bits = cg.target.cTypeBitSize(.long) },
            .c_longlong => .{ .signedness = .signed, .bits = cg.target.cTypeBitSize(.longlong) },
            .c_ulonglong => .{ .signedness = .unsigned, .bits = cg.target.cTypeBitSize(.longlong) },
            .f16, .f32, .f64, .f80, .f128, .c_longdouble => null,
            .anyopaque,
            .void,
            .type,
            .comptime_int,
            .comptime_float,
            .noreturn,
            .null,
            .undefined,
            .enum_literal,
            .adhoc_inferred_error_set,
            .generic_poison,
            => unreachable,
        },
        .struct_type => {
            const loaded_struct = ip.loadStructType(ty_index);
            switch (loaded_struct.layout) {
                .auto, .@"extern" => return null,
                .@"packed" => ty_index = loaded_struct.backingIntTypeUnordered(ip),
            }
        },
        .union_type => return switch (ip.loadUnionType(ty_index).flagsUnordered(ip).layout) {
            .auto, .@"extern" => null,
            .@"packed" => .{ .signedness = .unsigned, .bits = @intCast(ty.bitSize(zcu)) },
        },
        .enum_type => ty_index = ip.loadEnumType(ty_index).tag_ty,
        .error_set_type, .inferred_error_set_type => return .{ .signedness = .unsigned, .bits = zcu.errorSetBits() },
        else => return null,
    };
}

fn floatBits(cg: *CodeGen, ty: Type) ?u16 {
    return if (ty.isRuntimeFloat()) ty.floatBits(cg.target) else null;
}

const Temp = struct {
    index: Air.Inst.Index,

    fn unwrap(temp: Temp, cg: *CodeGen) union(enum) {
        ref: Air.Inst.Ref,
        temp: Index,
        err_ret_trace,
    } {
        switch (temp.index.unwrap()) {
            .ref => |ref| return .{ .ref = ref },
            .target => |target_index| {
                if (temp.index == err_ret_trace_index) return .err_ret_trace;
                const temp_index: Index = @enumFromInt(target_index);
                assert(temp_index.isValid(cg));
                return .{ .temp = temp_index };
            },
        }
    }

    fn typeOf(temp: Temp, cg: *CodeGen) Type {
        return switch (temp.unwrap(cg)) {
            .ref => switch (cg.air.instructions.items(.tag)[@intFromEnum(temp.index)]) {
                .loop_switch_br => cg.typeOf(cg.air.unwrapSwitch(temp.index).operand),
                else => cg.air.typeOfIndex(temp.index, &cg.pt.zcu.intern_pool),
            },
            .temp => |temp_index| temp_index.typeOf(cg),
            .err_ret_trace => .usize,
        };
    }

    fn isMut(temp: Temp, cg: *CodeGen) bool {
        return switch (temp.unwrap(cg)) {
            .ref, .err_ret_trace => false,
            .temp => |temp_index| switch (temp_index.tracking(cg).short) {
                .none,
                .unreach,
                .dead,
                .undef,
                .immediate,
                .eflags,
                .register_offset,
                .register_mask,
                .memory,
                .indirect,
                .indirect_load_frame,
                .lea_frame,
                .load_nav,
                .lea_nav,
                .load_uav,
                .lea_uav,
                .load_lazy_sym,
                .lea_lazy_sym,
                .lea_extern_func,
                .load_extern_func,
                .elementwise_args,
                .reserved_frame,
                .air_ref,
                => false,
                .register,
                .register_pair,
                .register_triple,
                .register_quadruple,
                .register_overflow,
                => true,
                .load_frame => |frame_addr| !frame_addr.index.isNamed(),
            },
        };
    }

    fn tracking(temp: Temp, cg: *CodeGen) InstTracking {
        return cg.inst_tracking.get(temp.index).?;
    }

    fn getOffset(temp: Temp, off: i32, cg: *CodeGen) InnerError!Temp {
        const new_temp_index = cg.next_temp_index;
        cg.temp_type[@intFromEnum(new_temp_index)] = .usize;
        cg.next_temp_index = @enumFromInt(@intFromEnum(new_temp_index) + 1);
        const mcv = temp.tracking(cg).short;
        switch (mcv) {
            else => std.debug.panic("{s}: {f}\n", .{ @src().fn_name, mcv }),
            .register => |reg| {
                const new_reg = try cg.register_manager.allocReg(new_temp_index.toIndex(), abi.RegisterClass.gp);
                new_temp_index.tracking(cg).* = .init(.{ .register = new_reg });
                try cg.asmRegisterMemory(.{ ._, .lea }, new_reg.to64(), .{
                    .base = .{ .reg = reg.to64() },
                    .mod = .{ .rm = .{ .disp = off } },
                });
            },
            .register_offset => |reg_off| {
                const new_reg = try cg.register_manager.allocReg(new_temp_index.toIndex(), abi.RegisterClass.gp);
                new_temp_index.tracking(cg).* = .init(.{ .register = new_reg });
                try cg.asmRegisterMemory(.{ ._, .lea }, new_reg.to64(), .{
                    .base = .{ .reg = reg_off.reg.to64() },
                    .mod = .{ .rm = .{ .disp = reg_off.off + off } },
                });
            },
            .load_frame, .load_nav, .lea_nav, .load_uav, .lea_uav, .load_lazy_sym, .lea_lazy_sym => {
                const new_reg = try cg.register_manager.allocReg(new_temp_index.toIndex(), abi.RegisterClass.gp);
                new_temp_index.tracking(cg).* = .init(.{ .register_offset = .{ .reg = new_reg, .off = off } });
                try cg.genSetReg(new_reg, .usize, mcv, .{});
            },
            .lea_frame => |frame_addr| new_temp_index.tracking(cg).* = .init(.{ .lea_frame = .{
                .index = frame_addr.index,
                .off = frame_addr.off + off,
            } }),
        }
        return .{ .index = new_temp_index.toIndex() };
    }

    fn toOffset(temp: *Temp, off: i32, cg: *CodeGen) InnerError!void {
        if (off == 0) return;
        switch (temp.unwrap(cg)) {
            .ref, .err_ret_trace => {},
            .temp => |temp_index| {
                const temp_tracking = temp_index.tracking(cg);
                switch (temp_tracking.short) {
                    else => {},
                    .register => |reg| {
                        try cg.freeValue(temp_tracking.long, .{});
                        temp_tracking.* = .init(.{ .register_offset = .{
                            .reg = reg,
                            .off = off,
                        } });
                        return;
                    },
                    .register_offset => |reg_off| {
                        try cg.freeValue(temp_tracking.long, .{});
                        temp_tracking.* = .init(.{ .register_offset = .{
                            .reg = reg_off.reg,
                            .off = reg_off.off + off,
                        } });
                        return;
                    },
                    .lea_frame => |frame_addr| {
                        assert(std.meta.eql(temp_tracking.long.lea_frame, frame_addr));
                        temp_tracking.* = .init(.{ .lea_frame = .{
                            .index = frame_addr.index,
                            .off = frame_addr.off + off,
                        } });
                        return;
                    },
                }
            },
        }
        const new_temp = try temp.getOffset(off, cg);
        try temp.die(cg);
        temp.* = new_temp;
    }

    fn getLimb(temp: Temp, limb_ty: Type, limb_index: u28, cg: *CodeGen) InnerError!Temp {
        const new_temp_index = cg.next_temp_index;
        cg.temp_type[@intFromEnum(new_temp_index)] = limb_ty;
        switch (temp.tracking(cg).short) {
            else => |mcv| std.debug.panic("{s}: {f}\n", .{ @src().fn_name, mcv }),
            .immediate => |imm| {
                assert(limb_index == 0);
                new_temp_index.tracking(cg).* = .init(.{ .immediate = imm });
            },
            .register => |reg| {
                assert(limb_index == 0);
                const new_reg =
                    try cg.register_manager.allocReg(new_temp_index.toIndex(), abi.RegisterClass.gp);
                new_temp_index.tracking(cg).* = .init(.{ .register = new_reg });
                try cg.asmRegisterRegister(.{ ._, .mov }, new_reg.to64(), reg.to64());
            },
            .register_pair => |regs| {
                const new_reg =
                    try cg.register_manager.allocReg(new_temp_index.toIndex(), abi.RegisterClass.gp);
                new_temp_index.tracking(cg).* = .init(.{ .register = new_reg });
                try cg.asmRegisterRegister(.{ ._, .mov }, new_reg.to64(), regs[limb_index].to64());
            },
            .register_offset => |reg_off| {
                assert(limb_index == 0);
                const new_reg =
                    try cg.register_manager.allocReg(new_temp_index.toIndex(), abi.RegisterClass.gp);
                new_temp_index.tracking(cg).* = .init(.{ .register = new_reg });
                try cg.asmRegisterMemory(.{ ._, .lea }, new_reg.to64(), .{
                    .base = .{ .reg = reg_off.reg.to64() },
                    .mod = .{ .rm = .{ .disp = reg_off.off + @as(u31, limb_index) * 8 } },
                });
            },
            .load_frame => |frame_addr| {
                const new_reg =
                    try cg.register_manager.allocReg(new_temp_index.toIndex(), abi.RegisterClass.gp);
                new_temp_index.tracking(cg).* = .init(.{ .register = new_reg });
                try cg.asmRegisterMemory(.{ ._, .mov }, new_reg.to64(), .{
                    .base = .{ .frame = frame_addr.index },
                    .mod = .{ .rm = .{
                        .size = .qword,
                        .disp = frame_addr.off + @as(u31, limb_index) * 8,
                    } },
                });
            },
            .lea_frame => |frame_addr| {
                assert(limb_index == 0);
                new_temp_index.tracking(cg).* = .init(.{ .lea_frame = frame_addr });
            },
            .load_nav => |nav| {
                const new_reg =
                    try cg.register_manager.allocReg(new_temp_index.toIndex(), abi.RegisterClass.gp);
                new_temp_index.tracking(cg).* = .init(.{ .register = new_reg });
                try cg.asmRegisterMemory(.{ ._, .mov }, new_reg.to64(), .{
                    .base = .{ .nav = nav },
                    .mod = .{ .rm = .{
                        .size = .qword,
                        .disp = @as(u31, limb_index) * 8,
                    } },
                });
            },
            .lea_nav => |nav| {
                assert(limb_index == 0);
                new_temp_index.tracking(cg).* = .init(.{ .lea_nav = nav });
            },
            .load_uav => |uav| {
                const new_reg =
                    try cg.register_manager.allocReg(new_temp_index.toIndex(), abi.RegisterClass.gp);
                new_temp_index.tracking(cg).* = .init(.{ .register = new_reg });
                try cg.asmRegisterMemory(.{ ._, .mov }, new_reg.to64(), .{
                    .base = .{ .uav = uav },
                    .mod = .{ .rm = .{
                        .size = .qword,
                        .disp = @as(u31, limb_index) * 8,
                    } },
                });
            },
            .lea_uav => |uav| {
                assert(limb_index == 0);
                new_temp_index.tracking(cg).* = .init(.{ .lea_uav = uav });
            },
            .load_lazy_sym => |lazy_sym| {
                const new_reg =
                    try cg.register_manager.allocReg(new_temp_index.toIndex(), abi.RegisterClass.gp);
                new_temp_index.tracking(cg).* = .init(.{ .register = new_reg });
                try cg.asmRegisterMemory(.{ ._, .mov }, new_reg.to64(), .{
                    .base = .{ .lazy_sym = lazy_sym },
                    .mod = .{ .rm = .{
                        .size = .qword,
                        .disp = @as(u31, limb_index) * 8,
                    } },
                });
            },
            .lea_lazy_sym => |lazy_sym| {
                assert(limb_index == 0);
                new_temp_index.tracking(cg).* = .init(.{ .lea_lazy_sym = lazy_sym });
            },
            .load_extern_func => |extern_func| {
                const new_reg =
                    try cg.register_manager.allocReg(new_temp_index.toIndex(), abi.RegisterClass.gp);
                new_temp_index.tracking(cg).* = .init(.{ .register = new_reg });
                try cg.asmRegisterMemory(.{ ._, .mov }, new_reg.to64(), .{
                    .base = .{ .extern_func = extern_func },
                    .mod = .{ .rm = .{
                        .size = .qword,
                        .disp = @as(u31, limb_index) * 8,
                    } },
                });
            },
            .lea_extern_func => |extern_func| {
                assert(limb_index == 0);
                new_temp_index.tracking(cg).* = .init(.{ .lea_extern_func = extern_func });
            },
        }
        cg.next_temp_index = @enumFromInt(@intFromEnum(new_temp_index) + 1);
        return .{ .index = new_temp_index.toIndex() };
    }

    fn getByteLen(temp: *Temp, cg: *CodeGen) Select.Error!Temp {
        const zcu = cg.pt.zcu;
        const ip = &zcu.intern_pool;
        const ptr_info = ip.indexToKey(temp.typeOf(cg).toIntern()).ptr_type;
        switch (ptr_info.flags.size) {
            .one => {
                const array_info = ip.indexToKey(ptr_info.child).array_type;
                return cg.tempInit(.usize, .{
                    .immediate = Type.fromInterned(array_info.child).abiSize(zcu) * array_info.len,
                });
            },
            .many, .c => unreachable,
            .slice => {
                const elem_size = Type.fromInterned(ptr_info.child).abiSize(zcu);
                var len = try temp.getLimb(.usize, 1, cg);
                while (try len.toRegClass(true, .general_purpose, cg)) {}
                const len_reg = len.tracking(cg).short.register.to64();
                if (!std.math.isPowerOfTwo(elem_size)) {
                    try cg.spillEflagsIfOccupied();
                    try cg.asmRegisterRegisterImmediate(
                        .{ .i_, .mul },
                        len_reg,
                        len_reg,
                        .u(elem_size),
                    );
                } else if (elem_size > 8) {
                    try cg.spillEflagsIfOccupied();
                    try cg.asmRegisterImmediate(
                        .{ ._l, .sh },
                        len_reg,
                        .u(std.math.log2_int(u64, elem_size)),
                    );
                } else if (elem_size != 1) try cg.asmRegisterMemory(.{ ._, .lea }, len_reg, .{
                    .mod = .{ .rm = .{
                        .index = len_reg,
                        .scale = .fromFactor(@intCast(elem_size)),
                    } },
                });
                return len;
            },
        }
    }

    fn toLimb(temp: *Temp, limb_ty: Type, limb_index: u28, cg: *CodeGen) InnerError!void {
        switch (temp.unwrap(cg)) {
            .ref => {},
            .temp => |temp_index| {
                const temp_tracking = temp_index.tracking(cg);
                switch (temp_tracking.short) {
                    else => {},
                    .register, .lea_frame, .lea_nav, .lea_uav, .lea_lazy_sym => {
                        assert(limb_index == 0);
                        cg.temp_type[@intFromEnum(temp_index)] = limb_ty;
                        return;
                    },
                    .register_pair => |regs| {
                        switch (temp_tracking.long) {
                            .none, .reserved_frame => {},
                            else => temp_tracking.long =
                                temp_tracking.long.address().offset(@as(u31, limb_index) * 8).deref(),
                        }
                        for (regs, 0..) |reg, reg_index| if (reg_index != limb_index)
                            cg.register_manager.freeReg(reg);
                        temp_tracking.* = .init(.{ .register = regs[limb_index] });
                        cg.temp_type[@intFromEnum(temp_index)] = limb_ty;
                        return;
                    },
                    .load_frame => |frame_addr| if (!frame_addr.index.isNamed()) {
                        assert(std.meta.eql(temp_tracking.long.load_frame, frame_addr));
                        temp_tracking.* = .init(.{ .load_frame = .{
                            .index = frame_addr.index,
                            .off = frame_addr.off + @as(u31, limb_index) * 8,
                        } });
                        cg.temp_type[@intFromEnum(temp_index)] = limb_ty;
                        return;
                    },
                }
            },
            .err_ret_trace => unreachable,
        }
        const new_temp = try temp.getLimb(limb_ty, limb_index, cg);
        try temp.die(cg);
        temp.* = new_temp;
    }

    fn toSlicePtr(temp: *Temp, cg: *CodeGen) InnerError!void {
        const temp_ty = temp.typeOf(cg);
        if (temp_ty.isSlice(cg.pt.zcu)) try temp.toLimb(temp_ty.slicePtrFieldType(cg.pt.zcu), 0, cg);
    }

    fn toSliceLen(temp: *Temp, cg: *CodeGen) InnerError!void {
        try temp.toLimb(.usize, 1, cg);
    }

    fn toReg(temp: *Temp, new_reg: Register, cg: *CodeGen) InnerError!bool {
        const ty: Type = ty: switch (temp.unwrap(cg)) {
            .ref => |ref| cg.typeOf(ref),
            .temp => |temp_index| {
                const temp_tracking = temp_index.tracking(cg);
                if (temp_tracking.short == .register and
                    temp_tracking.short.register == new_reg) return false;
                break :ty temp_index.typeOf(cg);
            },
            .err_ret_trace => .usize,
        };
        const new_temp_index = cg.next_temp_index;
        cg.next_temp_index = @enumFromInt(@intFromEnum(new_temp_index) + 1);
        try cg.register_manager.getReg(new_reg, new_temp_index.toIndex());
        cg.temp_type[@intFromEnum(new_temp_index)] = ty;
        new_temp_index.tracking(cg).* = .init(.{ .register = new_reg });
        while (try temp.toBase(false, cg)) {}
        try temp.readTo(ty, .{ .register = new_reg }, .{}, cg);
        try temp.die(cg);
        temp.* = .{ .index = new_temp_index.toIndex() };
        return true;
    }

    fn toRegPair(temp: *Temp, new_regs: [2]Register, cg: *CodeGen) InnerError!bool {
        const ty: Type = ty: switch (temp.unwrap(cg)) {
            .ref => |ref| cg.typeOf(ref),
            .temp => |temp_index| {
                const temp_tracking = temp_index.tracking(cg);
                if (temp_tracking.short == .register_pair and
                    std.mem.eql(Register, &temp_tracking.short.register_pair, &new_regs)) return false;
                break :ty temp_index.typeOf(cg);
            },
            .err_ret_trace => .usize,
        };
        const new_temp_index = cg.next_temp_index;
        cg.next_temp_index = @enumFromInt(@intFromEnum(new_temp_index) + 1);
        for (new_regs) |new_reg| try cg.register_manager.getReg(new_reg, new_temp_index.toIndex());
        cg.temp_type[@intFromEnum(new_temp_index)] = ty;
        new_temp_index.tracking(cg).* = .init(.{ .register_pair = new_regs });
        while (try temp.toBase(false, cg)) {}
        for (new_regs, 0..) |new_reg, reg_index| try temp.readTo(
            .usize,
            .{ .register = new_reg },
            .{ .disp = @intCast(8 * reg_index) },
            cg,
        );
        try temp.die(cg);
        temp.* = .{ .index = new_temp_index.toIndex() };
        return true;
    }

    fn toRegClass(temp: *Temp, mut: bool, rc: Register.Class, cg: *CodeGen) InnerError!bool {
        const val = temp.tracking(cg).short;
        if (!mut or temp.isMut(cg)) switch (val) {
            else => {},
            .register => |reg| if (reg.isClass(rc)) return false,
            .register_offset => |reg_off| if (reg_off.off == 0 and reg_off.reg.isClass(rc)) return false,
        };
        const ty = temp.typeOf(cg);
        const new_temp_index = cg.next_temp_index;
        cg.temp_type[@intFromEnum(new_temp_index)] = ty;
        const new_reg = try cg.register_manager.allocReg(new_temp_index.toIndex(), regSetForRegClass(rc));
        try cg.genSetReg(new_reg, ty, val, .{});
        new_temp_index.tracking(cg).* = .init(.{ .register = new_reg });
        try temp.die(cg);
        cg.next_temp_index = @enumFromInt(@intFromEnum(new_temp_index) + 1);
        temp.* = .{ .index = new_temp_index.toIndex() };
        return true;
    }

    fn toPair(first_temp: *Temp, second_temp: *Temp, cg: *CodeGen) InnerError!void {
        while (true) for ([_]*Temp{ first_temp, second_temp }) |part_temp| {
            if (try part_temp.toRegClass(true, .general_purpose, cg)) break;
        } else break;
        const first_temp_tracking = first_temp.unwrap(cg).temp.tracking(cg);
        const second_temp_tracking = second_temp.unwrap(cg).temp.tracking(cg);
        const result: MCValue = .{ .register_pair = .{
            first_temp_tracking.short.register.to64(),
            second_temp_tracking.short.register.to64(),
        } };
        const result_temp_index = cg.next_temp_index;
        const result_temp: Temp = .{ .index = result_temp_index.toIndex() };
        assert(cg.reuseTemp(result_temp.index, first_temp.index, first_temp_tracking));
        assert(cg.reuseTemp(result_temp.index, second_temp.index, second_temp_tracking));
        result_temp_index.tracking(cg).* = .init(result);
        cg.temp_type[@intFromEnum(result_temp_index)] = .slice_const_u8;
        cg.next_temp_index = @enumFromInt(@intFromEnum(result_temp_index) + 1);
        first_temp.* = result_temp;
        second_temp.* = result_temp;
    }

    fn withOverflow(temp: *Temp, overflow_temp: *Temp, cg: *CodeGen) InnerError!void {
        const temp_index = temp.unwrap(cg).temp;
        const temp_tracking = temp_index.tracking(cg);
        const overflow_temp_tracking = overflow_temp.unwrap(cg).temp.tracking(cg);
        switch (temp_tracking.short) {
            .register => |reg| switch (overflow_temp_tracking.short) {
                .eflags => |overflow_cc| {
                    const result_temp_index = cg.next_temp_index;
                    const result_temp: Temp = .{ .index = result_temp_index.toIndex() };
                    assert(cg.reuseTemp(result_temp.index, temp.index, temp_tracking));
                    assert(cg.reuseTemp(result_temp.index, overflow_temp.index, overflow_temp_tracking));
                    result_temp_index.tracking(cg).* = .init(.{ .register_overflow = .{ .reg = reg, .eflags = overflow_cc } });
                    cg.temp_type[@intFromEnum(result_temp_index)] = .slice_const_u8;
                    cg.next_temp_index = @enumFromInt(@intFromEnum(result_temp_index) + 1);
                    temp.* = result_temp;
                    overflow_temp.* = result_temp;
                    return;
                },
                .register => |overflow_reg| {
                    const result_temp_index = cg.next_temp_index;
                    const result_temp: Temp = .{ .index = result_temp_index.toIndex() };
                    assert(cg.reuseTemp(result_temp.index, temp.index, temp_tracking));
                    assert(cg.reuseTemp(result_temp.index, overflow_temp.index, overflow_temp_tracking));
                    result_temp_index.tracking(cg).* = .init(.{ .register_pair = .{ reg, overflow_reg } });
                    cg.temp_type[@intFromEnum(result_temp_index)] = .slice_const_u8;
                    cg.next_temp_index = @enumFromInt(@intFromEnum(result_temp_index) + 1);
                    temp.* = result_temp;
                    overflow_temp.* = result_temp;
                    return;
                },
                else => {},
            },
            .load_frame => {
                const zcu = cg.pt.zcu;
                const ip = &zcu.intern_pool;
                const field_tys = ip.indexToKey(temp_index.typeOf(cg).toIntern()).tuple_type.types.get(ip);
                try temp.write(overflow_temp, .{ .disp = @intCast(Type.fromInterned(field_tys[0]).abiSize(zcu)) }, cg);
                try overflow_temp.die(cg);
                overflow_temp.* = temp.*;
                return;
            },
            else => {},
        }
        std.debug.panic("{s}: {f} {f}\n", .{ @src().fn_name, temp_tracking, overflow_temp_tracking });
    }

    fn asMask(temp: Temp, info: MaskInfo, cg: *CodeGen) void {
        assert(info.scalar != .none);
        const mcv = &temp.unwrap(cg).temp.tracking(cg).short;
        const reg = mcv.register;
        mcv.* = .{ .register_mask = .{ .reg = reg, .info = info } };
    }

    fn toLea(temp: *Temp, cg: *CodeGen) InnerError!bool {
        switch (temp.tracking(cg).short) {
            .none,
            .unreach,
            .dead,
            .undef,
            .eflags,
            .register_pair,
            .register_triple,
            .register_quadruple,
            .register_overflow,
            .register_mask,
            .indirect_load_frame,
            .elementwise_args,
            .reserved_frame,
            .air_ref,
            => unreachable, // not a valid pointer
            .immediate,
            .register,
            .register_offset,
            .lea_frame,
            => return false,
            .memory,
            .indirect,
            .load_frame,
            .load_nav,
            .lea_nav,
            .load_uav,
            .lea_uav,
            .load_lazy_sym,
            .lea_lazy_sym,
            .load_extern_func,
            .lea_extern_func,
            => return temp.toRegClass(true, .general_purpose, cg),
        }
    }

    fn toMemory(temp: *Temp, mut: bool, cg: *CodeGen) InnerError!bool {
        const temp_tracking = temp.tracking(cg);
        if ((!mut or temp.isMut(cg)) and temp_tracking.short.isMemory()) return false;
        const new_temp_index = cg.next_temp_index;
        const ty = temp.typeOf(cg);
        cg.temp_type[@intFromEnum(new_temp_index)] = ty;
        const new_frame_index = try cg.allocFrameIndex(.initSpill(ty, cg.pt.zcu));
        try cg.genSetMem(.{ .frame = new_frame_index }, 0, ty, temp_tracking.short, .{});
        new_temp_index.tracking(cg).* = .init(.{ .load_frame = .{ .index = new_frame_index } });
        try temp.die(cg);
        cg.next_temp_index = @enumFromInt(@intFromEnum(new_temp_index) + 1);
        temp.* = .{ .index = new_temp_index.toIndex() };
        return true;
    }

    // hack around linker relocation bugs
    fn toBase(temp: *Temp, mut: bool, cg: *CodeGen) InnerError!bool {
        const temp_tracking = temp.tracking(cg);
        if ((!mut or temp.isMut(cg)) and temp_tracking.short.isBase()) return false;
        if (try temp.toMemory(mut, cg)) return true;
        const new_temp_index = cg.next_temp_index;
        cg.temp_type[@intFromEnum(new_temp_index)] = temp.typeOf(cg);
        const new_reg =
            try cg.register_manager.allocReg(new_temp_index.toIndex(), abi.RegisterClass.gp);
        try cg.genSetReg(new_reg, .usize, temp_tracking.short.address(), .{});
        new_temp_index.tracking(cg).* = .init(.{ .indirect = .{ .reg = new_reg } });
        try temp.die(cg);
        cg.next_temp_index = @enumFromInt(@intFromEnum(new_temp_index) + 1);
        temp.* = .{ .index = new_temp_index.toIndex() };
        return true;
    }

    const AccessOptions = struct {
        disp: i32 = 0,
        safe: bool = false,
    };

    fn load(ptr: *Temp, val_ty: Type, opts: AccessOptions, cg: *CodeGen) InnerError!Temp {
        const val = try cg.tempAlloc(val_ty);
        try ptr.toOffset(opts.disp, cg);
        while (try ptr.toLea(cg)) {}
        const val_mcv = val.tracking(cg).short;
        switch (val_mcv) {
            else => |mcv| std.debug.panic("{s}: {f}\n", .{ @src().fn_name, mcv }),
            .register => |val_reg| try ptr.loadReg(val_ty, registerAlias(
                val_reg,
                @intCast(val_ty.abiSize(cg.pt.zcu)),
            ), cg),
            inline .register_pair,
            .register_triple,
            .register_quadruple,
            => |val_regs| for (val_regs) |val_reg| {
                try ptr.loadReg(val_ty, val_reg, cg);
                try ptr.toOffset(@intCast(@divExact(val_reg.size().bitSize(cg.target), 8)), cg);
                while (try ptr.toLea(cg)) {}
            },
            .register_offset => |val_reg_off| switch (val_reg_off.off) {
                0 => try ptr.loadReg(val_ty, registerAlias(
                    val_reg_off.reg,
                    @intCast(val_ty.abiSize(cg.pt.zcu)),
                ), cg),
                else => unreachable,
            },
            .memory, .indirect, .load_frame, .load_nav, .load_uav, .load_lazy_sym => {
                var val_ptr = try cg.tempInit(.usize, val_mcv.address());
                try val_ptr.memcpy(ptr, val_ty.abiSize(cg.pt.zcu), cg);
                try val_ptr.die(cg);
            },
        }
        return val;
    }

    fn store(ptr: *Temp, val: *Temp, opts: AccessOptions, cg: *CodeGen) InnerError!void {
        const val_ty = val.typeOf(cg);
        try ptr.toOffset(opts.disp, cg);
        while (try ptr.toLea(cg)) {}
        val_to_gpr: while (true) : (while (try ptr.toLea(cg) or
            try val.toRegClass(false, .general_purpose, cg))
        {}) {
            const val_mcv = val.tracking(cg).short;
            switch (val_mcv) {
                else => |mcv| std.debug.panic("{s}: {f}\n", .{ @src().fn_name, mcv }),
                .undef => if (opts.safe) {
                    var pat = try cg.tempInit(.u8, .{ .immediate = 0xaa });
                    var len = try cg.tempInit(.usize, .{ .immediate = val_ty.abiSize(cg.pt.zcu) });
                    try ptr.memset(&pat, &len, cg);
                    try pat.die(cg);
                    try len.die(cg);
                },
                .immediate => |val_imm| {
                    const val_op: Immediate = if (std.math.cast(u31, val_imm)) |val_uimm31|
                        .u(val_uimm31)
                    else if (std.math.cast(i32, @as(i64, @bitCast(val_imm)))) |val_simm32|
                        .s(val_simm32)
                    else
                        continue :val_to_gpr;
                    // hack around linker relocation bugs
                    switch (ptr.tracking(cg).short) {
                        else => {},
                        .lea_nav,
                        .lea_uav,
                        .lea_lazy_sym,
                        .lea_extern_func,
                        => while (try ptr.toRegClass(false, .general_purpose, cg)) {},
                    }
                    try cg.asmMemoryImmediate(
                        .{ ._, .mov },
                        try ptr.tracking(cg).short.deref().mem(cg, .{
                            .size = cg.memSize(val_ty),
                        }),
                        val_op,
                    );
                },
                .eflags => |cc| {
                    // hack around linker relocation bugs
                    switch (ptr.tracking(cg).short) {
                        else => {},
                        .lea_nav,
                        .lea_uav,
                        .lea_lazy_sym,
                        .lea_extern_func,
                        => while (try ptr.toRegClass(false, .general_purpose, cg)) {},
                    }
                    try cg.asmSetccMemory(
                        cc,
                        try ptr.tracking(cg).short.deref().mem(cg, .{ .size = .byte }),
                    );
                },
                .register => |val_reg| try ptr.storeRegs(val_ty, &.{registerAlias(
                    val_reg,
                    @intCast(val_ty.abiSize(cg.pt.zcu)),
                )}, cg),
                inline .register_pair,
                .register_triple,
                .register_quadruple,
                => |val_regs| try ptr.storeRegs(val_ty, &val_regs, cg),
                .register_offset => |val_reg_off| switch (val_reg_off.off) {
                    0 => try ptr.storeRegs(val_ty, &.{registerAlias(
                        val_reg_off.reg,
                        @intCast(val_ty.abiSize(cg.pt.zcu)),
                    )}, cg),
                    else => continue :val_to_gpr,
                },
                .register_overflow => |val_reg_ov| {
                    const ip = &cg.pt.zcu.intern_pool;
                    const first_ty: Type = .fromInterned(first_ty: switch (ip.indexToKey(val_ty.toIntern())) {
                        .tuple_type => |tuple_type| {
                            const tuple_field_types = tuple_type.types.get(ip);
                            assert(tuple_field_types.len == 2 and tuple_field_types[1] == .u1_type);
                            break :first_ty tuple_field_types[0];
                        },
                        .opt_type => |opt_child| {
                            assert(!val_ty.optionalReprIsPayload(cg.pt.zcu));
                            break :first_ty opt_child;
                        },
                        else => std.debug.panic("{s}: {f}\n", .{ @src().fn_name, val_ty.fmt(cg.pt) }),
                    });
                    const first_size: u31 = @intCast(first_ty.abiSize(cg.pt.zcu));
                    try ptr.storeRegs(first_ty, &.{registerAlias(val_reg_ov.reg, first_size)}, cg);
                    try ptr.toOffset(first_size, cg);
                    try cg.asmSetccMemory(
                        val_reg_ov.eflags,
                        try ptr.tracking(cg).short.deref().mem(cg, .{ .size = .byte }),
                    );
                },
                .lea_frame, .lea_nav, .lea_uav, .lea_lazy_sym => continue :val_to_gpr,
                .memory, .indirect, .load_frame, .load_nav, .load_uav, .load_lazy_sym => {
                    var val_ptr = try cg.tempInit(.usize, val_mcv.address());
                    try ptr.memcpy(&val_ptr, val_ty.abiSize(cg.pt.zcu), cg);
                    try val_ptr.die(cg);
                },
            }
            break;
        }
    }

    fn read(src: *Temp, val_ty: Type, opts: AccessOptions, cg: *CodeGen) InnerError!Temp {
        var val = try cg.tempAlloc(val_ty);
        while (try src.toBase(false, cg)) {}
        try src.readTo(val_ty, val.tracking(cg).short, opts, cg);
        return val;
    }

    fn readTo(src: *Temp, val_ty: Type, val_mcv: MCValue, opts: AccessOptions, cg: *CodeGen) InnerError!void {
        switch (val_mcv) {
            else => |mcv| std.debug.panic("{s}: {f}\n", .{ @src().fn_name, mcv }),
            .register => |val_reg| try src.readReg(opts.disp, val_ty, registerAlias(
                val_reg,
                @intCast(cg.unalignedSize(val_ty)),
            ), cg),
            inline .register_pair, .register_triple, .register_quadruple => |val_regs| {
                var disp = opts.disp;
                for (val_regs) |val_reg| {
                    try src.readReg(disp, val_ty, val_reg, cg);
                    disp += @intCast(@divExact(val_reg.size().bitSize(cg.target), 8));
                }
            },
            .register_offset => |val_reg_off| switch (val_reg_off.off) {
                0 => try src.readReg(opts.disp, val_ty, registerAlias(
                    val_reg_off.reg,
                    @intCast(val_ty.abiSize(cg.pt.zcu)),
                ), cg),
                else => unreachable,
            },
            .memory, .indirect, .load_frame, .load_nav, .load_uav, .load_lazy_sym => {
                var val_ptr = try cg.tempInit(.usize, val_mcv.address());
                var src_ptr =
                    try cg.tempInit(.usize, src.tracking(cg).short.address().offset(opts.disp));
                try val_ptr.memcpy(&src_ptr, val_ty.abiSize(cg.pt.zcu), cg);
                try val_ptr.die(cg);
                try src_ptr.die(cg);
            },
        }
    }

    fn write(dst: *Temp, val: *Temp, opts: AccessOptions, cg: *CodeGen) InnerError!void {
        const val_ty = val.typeOf(cg);
        while (try dst.toBase(false, cg)) {}
        val_to_gpr: while (true) : (while (try dst.toBase(false, cg) or
            try val.toRegClass(false, .general_purpose, cg))
        {}) {
            const val_mcv = val.tracking(cg).short;
            switch (val_mcv) {
                else => |mcv| std.debug.panic("{s}: {f}\n", .{ @src().fn_name, mcv }),
                .none => {},
                .undef => if (opts.safe) {
                    var dst_ptr = try cg.tempInit(.usize, dst.tracking(cg).short.address().offset(opts.disp));
                    var pat = try cg.tempInit(.u8, .{ .immediate = 0xaa });
                    var len = try cg.tempInit(.usize, .{ .immediate = val_ty.abiSize(cg.pt.zcu) });
                    try dst_ptr.memset(&pat, &len, cg);
                    try dst_ptr.die(cg);
                    try pat.die(cg);
                    try len.die(cg);
                },
                .immediate => |val_imm| {
                    const val_op: Immediate = if (std.math.cast(u31, val_imm)) |val_uimm31|
                        .u(val_uimm31)
                    else if (std.math.cast(i32, @as(i64, @bitCast(val_imm)))) |val_simm32|
                        .s(val_simm32)
                    else
                        continue :val_to_gpr;
                    try cg.asmMemoryImmediate(
                        .{ ._, .mov },
                        try dst.tracking(cg).short.mem(cg, .{
                            .size = cg.memSize(val_ty),
                            .disp = opts.disp,
                        }),
                        val_op,
                    );
                },
                .eflags => |cc| try cg.asmSetccMemory(
                    cc,
                    try dst.tracking(cg).short.mem(cg, .{
                        .size = .byte,
                        .disp = opts.disp,
                    }),
                ),
                .register => |val_reg| try dst.writeReg(opts.disp, val_ty, registerAlias(
                    val_reg,
                    @intCast(val_ty.abiSize(cg.pt.zcu)),
                ), cg),
                inline .register_pair,
                .register_triple,
                .register_quadruple,
                => |val_regs| try dst.writeRegs(opts.disp, val_ty, &val_regs, cg),
                .register_offset => |val_reg_off| switch (val_reg_off.off) {
                    0 => try dst.writeReg(opts.disp, val_ty, registerAlias(
                        val_reg_off.reg,
                        @intCast(val_ty.abiSize(cg.pt.zcu)),
                    ), cg),
                    else => continue :val_to_gpr,
                },
                .register_overflow => |val_reg_ov| {
                    const ip = &cg.pt.zcu.intern_pool;
                    const first_ty: Type = .fromInterned(first_ty: switch (ip.indexToKey(val_ty.toIntern())) {
                        .tuple_type => |tuple_type| {
                            const tuple_field_types = tuple_type.types.get(ip);
                            assert(tuple_field_types.len == 2 and tuple_field_types[1] == .u1_type);
                            break :first_ty tuple_field_types[0];
                        },
                        .opt_type => |opt_child| {
                            assert(!val_ty.optionalReprIsPayload(cg.pt.zcu));
                            break :first_ty opt_child;
                        },
                        else => std.debug.panic("{s}: {f}\n", .{ @src().fn_name, val_ty.fmt(cg.pt) }),
                    });
                    const first_size: u31 = @intCast(first_ty.abiSize(cg.pt.zcu));
                    try dst.writeReg(opts.disp, first_ty, registerAlias(val_reg_ov.reg, first_size), cg);
                    try cg.asmSetccMemory(
                        val_reg_ov.eflags,
                        try dst.tracking(cg).short.mem(cg, .{
                            .size = .byte,
                            .disp = opts.disp + first_size,
                        }),
                    );
                },
                .lea_frame, .lea_nav, .lea_uav, .lea_lazy_sym => continue :val_to_gpr,
                .memory, .indirect, .load_frame, .load_nav, .load_uav, .load_lazy_sym => {
                    var dst_ptr =
                        try cg.tempInit(.usize, dst.tracking(cg).short.address().offset(opts.disp));
                    var val_ptr = try cg.tempInit(.usize, val_mcv.address());
                    try dst_ptr.memcpy(&val_ptr, val_ty.abiSize(cg.pt.zcu), cg);
                    try dst_ptr.die(cg);
                    try val_ptr.die(cg);
                },
            }
            break;
        }
    }

    fn loadReg(ptr: *Temp, dst_ty: Type, dst_reg: Register, cg: *CodeGen) InnerError!void {
        const dst_rc = dst_reg.class();
        const strat = try cg.moveStrategy(dst_ty, dst_rc, false);
        // hack around linker relocation bugs
        switch (ptr.tracking(cg).short) {
            else => {},
            .lea_nav, .lea_uav, .lea_lazy_sym => if (dst_rc != .general_purpose)
                while (try ptr.toRegClass(false, .general_purpose, cg)) {},
        }
        try strat.read(cg, dst_reg, try ptr.tracking(cg).short.deref().mem(cg, .{
            .size = cg.memSize(dst_ty),
        }));
    }

    fn storeRegs(ptr: *Temp, src_ty: Type, src_regs: []const Register, cg: *CodeGen) InnerError!void {
        const zcu = cg.pt.zcu;
        const ip = &zcu.intern_pool;
        var part_disp: u31 = 0;
        var deferred_disp: u31 = 0;
        var src_abi_size: u32 = @intCast(src_ty.abiSize(cg.pt.zcu));
        for (src_regs, 0..) |src_reg, part_index| {
            const part_ty: Type = if (src_regs.len == 1)
                src_ty
            else if (cg.intInfo(src_ty)) |int_info| part_ty: {
                assert(src_regs.len == std.math.divCeil(u16, int_info.bits, 64) catch unreachable);
                break :part_ty .u64;
            } else part_ty: switch (ip.indexToKey(src_ty.toIntern())) {
                else => std.debug.panic("{s}: {f}\n", .{ @src().fn_name, src_ty.fmt(cg.pt) }),
                .ptr_type => |ptr_info| {
                    assert(ptr_info.flags.size == .slice);
                    assert(src_regs.len == 2);
                    break :part_ty .usize;
                },
                .array_type => {
                    assert(src_regs.len - part_index == std.math.divCeil(u32, src_abi_size, 8) catch unreachable);
                    break :part_ty try cg.pt.intType(.unsigned, @as(u16, 8) * @min(src_abi_size, 8));
                },
                .vector_type => |vector_type| try cg.pt.vectorType(.{
                    .len = @intCast(@divExact(vector_type.len, src_regs.len)),
                    .child = vector_type.child,
                }),
                .opt_type => |opt_child| switch (ip.indexToKey(opt_child)) {
                    else => std.debug.panic("{s}: {f}\n", .{ @src().fn_name, src_ty.fmt(cg.pt) }),
                    .ptr_type => |ptr_info| {
                        assert(ptr_info.flags.size == .slice);
                        assert(src_regs.len == 2);
                        break :part_ty .usize;
                    },
                },
                .struct_type => {
                    assert(src_regs.len - part_index == std.math.divCeil(u32, src_abi_size, 8) catch unreachable);
                    break :part_ty switch (src_abi_size) {
                        0, 3, 5...7 => unreachable,
                        1 => .u8,
                        2 => .u16,
                        4 => .u32,
                        else => .u64,
                    };
                },
                .tuple_type => |tuple_type| {
                    assert(tuple_type.types.len == src_regs.len);
                    break :part_ty .fromInterned(tuple_type.types.get(ip)[part_index]);
                },
            };
            const part_size: u31 = @intCast(part_ty.abiSize(zcu));
            const src_rc = src_reg.class();
            if (src_rc == .x87 or std.math.isPowerOfTwo(part_size)) {
                // hack around linker relocation bugs
                switch (ptr.tracking(cg).short) {
                    else => {},
                    .lea_nav, .lea_uav, .lea_lazy_sym => while (try ptr.toRegClass(false, .general_purpose, cg)) {},
                }
                const strat = try cg.moveStrategy(part_ty, src_rc, false);
                try strat.write(cg, try ptr.tracking(cg).short.deref().mem(cg, .{
                    .size = switch (src_rc) {
                        else => .fromBitSize(8 * part_size),
                        .x87 => switch (abi.classifySystemV(src_ty, zcu, cg.target, .other)[part_index]) {
                            else => unreachable,
                            .float => .dword,
                            .float_combine, .sse => .qword,
                            .x87 => .tbyte,
                        },
                    },
                    .disp = part_disp,
                }), registerAlias(src_reg, part_size));
            } else {
                const frame_size = std.math.ceilPowerOfTwoAssert(u32, part_size);
                const frame_index = try cg.allocFrameIndex(.init(.{
                    .size = frame_size,
                    .alignment = .fromNonzeroByteUnits(frame_size),
                }));
                const strat = try cg.moveStrategy(part_ty, src_rc, true);
                try strat.write(cg, .{
                    .base = .{ .frame = frame_index },
                    .mod = .{ .rm = .{ .size = .fromSize(frame_size) } },
                }, registerAlias(src_reg, frame_size));
                try ptr.toOffset(deferred_disp, cg);
                deferred_disp = 0;
                var src_ptr = try cg.tempInit(.usize, .{ .lea_frame = .{ .index = frame_index } });
                try ptr.memcpy(&src_ptr, src_abi_size, cg);
                try src_ptr.die(cg);
            }
            part_disp += part_size;
            deferred_disp += part_size;
            src_abi_size -= part_size;
        }
    }

    fn readReg(src: Temp, disp: i32, dst_ty: Type, dst_reg: Register, cg: *CodeGen) InnerError!void {
        const strat = try cg.moveStrategy(dst_ty, dst_reg.class(), false);
        try strat.read(cg, dst_reg, try src.tracking(cg).short.mem(cg, .{
            .size = cg.memSize(dst_ty),
            .disp = disp,
        }));
    }

    fn writeReg(dst: Temp, disp: i32, src_ty: Type, src_reg: Register, cg: *CodeGen) InnerError!void {
        const src_abi_size: u31 = @intCast(src_ty.abiSize(cg.pt.zcu));
        const src_rc = src_reg.class();
        if (src_rc == .x87 or std.math.isPowerOfTwo(src_abi_size)) {
            const strat = try cg.moveStrategy(src_ty, src_rc, false);
            try strat.write(cg, try dst.tracking(cg).short.mem(cg, .{
                .size = cg.memSize(src_ty),
                .disp = disp,
            }), registerAlias(src_reg, src_abi_size));
        } else {
            const frame_size = std.math.ceilPowerOfTwoAssert(u32, src_abi_size);
            const frame_index = try cg.allocFrameIndex(.init(.{
                .size = frame_size,
                .alignment = .fromNonzeroByteUnits(frame_size),
            }));
            const strat = try cg.moveStrategy(src_ty, src_rc, true);
            try strat.write(cg, .{
                .base = .{ .frame = frame_index },
                .mod = .{ .rm = .{ .size = .fromSize(frame_size) } },
            }, registerAlias(src_reg, frame_size));
            var dst_ptr = try cg.tempInit(.usize, dst.tracking(cg).short.address());
            try dst_ptr.toOffset(disp, cg);
            var src_ptr = try cg.tempInit(.usize, .{ .lea_frame = .{ .index = frame_index } });
            try dst_ptr.memcpy(&src_ptr, src_abi_size, cg);
            try dst_ptr.die(cg);
            try src_ptr.die(cg);
        }
    }

    fn writeRegs(dst: Temp, disp: i32, src_ty: Type, src_regs: []const Register, cg: *CodeGen) InnerError!void {
        const zcu = cg.pt.zcu;
        const classes = std.mem.sliceTo(&abi.classifySystemV(src_ty, zcu, cg.target, .other), .none);
        var next_class_index: u4 = 0;
        var part_disp = disp;
        var remaining_abi_size = src_ty.abiSize(zcu);
        for (src_regs) |src_reg| {
            const class_index = next_class_index;
            const class = classes[class_index];
            next_class_index = @intCast(switch (class) {
                .integer, .memory, .float, .float_combine => class_index + 1,
                .sse => std.mem.indexOfNonePos(abi.Class, classes, class_index + 1, &.{.sseup}) orelse classes.len,
                .x87 => std.mem.indexOfNonePos(abi.Class, classes, class_index + 1, &.{.x87up}) orelse classes.len,
                .sseup, .x87up, .none, .win_i128, .integer_per_element => unreachable,
            });
            const part_size = switch (class) {
                .integer, .sse, .memory => @min(8 * @as(u7, next_class_index - class_index), remaining_abi_size),
                .x87 => 16,
                .float => 4,
                .float_combine => 8,
                .sseup, .x87up, .none, .win_i128, .integer_per_element => unreachable,
            };
            try dst.writeReg(part_disp, switch (class) {
                .integer => .u64,
                .sse => switch (part_size) {
                    else => unreachable,
                    8 => .f64,
                    16 => .vector_2_f64,
                    32 => .vector_4_f64,
                },
                .x87 => .f80,
                .float => .f32,
                .float_combine => .vector_2_f32,
                .sseup, .x87up, .memory, .none, .win_i128, .integer_per_element => unreachable,
            }, src_reg, cg);
            part_disp += part_size;
            remaining_abi_size -= part_size;
        }
        assert(next_class_index == classes.len);
    }

    fn memcpy(dst: *Temp, src: *Temp, len: u64, cg: *CodeGen) InnerError!void {
        if (cg.useConstMemcpyForSize(len)) {
            while (try dst.toLea(cg) or try src.toLea(cg)) {} // `genConstMemcpy` wants these values to be address operands
            if (try cg.genConstMemcpy(dst.tracking(cg).short, src.tracking(cg).short, len)) {
                return;
            }
        }
        var temp = try cg.tempAllocReg(.usize, abi.RegisterClass.gp);
        while (try dst.toReg(.rdi, cg) or
            try src.toReg(.rsi, cg) or
            try temp.toReg(.rcx, cg))
        {}
        try cg.asmRegisterImmediate(.{ ._, .mov }, .rcx, .{ .unsigned = len });
        try cg.asmOpOnly(.{ .@"rep _sb", .mov });
        try temp.die(cg);
    }

    fn memset(dst: *Temp, val: *Temp, len: *Temp, cg: *CodeGen) InnerError!void {
        while (true) for ([_]*Temp{ dst, val, len }, [_]Register{ .rdi, .rax, .rcx }) |temp, reg| {
            if (try temp.toReg(reg, cg)) break;
        } else break;
        try cg.asmOpOnly(.{ .@"rep _sb", .sto });
    }

    fn wrapInt(temp: *Temp, cg: *CodeGen) Select.Error!void {
        var ops: [1]Temp = .{temp.*};
        var res: [1]Temp = undefined;
        try cg.select(&res, &.{temp.typeOf(cg)}, &ops, comptime &.{ .{
            .src_constraints = .{ .{ .exact_int = 8 }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .mut_mem, .none, .none } },
                .{ .src = .{ .to_mut_gpr, .none, .none } },
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .each = .{ .once = &.{} },
        }, .{
            .src_constraints = .{ .{ .signed_int = .byte }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mut_gpr, .none, .none } },
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._l, .sa, .dst0b, .uia(8, .src0, .sub_bit_size), ._, ._ },
                .{ ._, ._r, .sa, .dst0b, .uia(8, .src0, .sub_bit_size), ._, ._ },
            } },
        }, .{
            .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .mut_mem, .none, .none } },
                .{ .src = .{ .to_mut_gpr, .none, .none } },
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .@"and", .dst0b, .ua(.src0, .add_umax), ._, ._ },
            } },
        }, .{
            .src_constraints = .{ .{ .exact_int = 16 }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .mut_mem, .none, .none } },
                .{ .src = .{ .to_mut_gpr, .none, .none } },
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .each = .{ .once = &.{} },
        }, .{
            .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .mut_mem, .none, .none } },
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .@"and", .dst0w, .ua(.src0, .add_umax), ._, ._ },
            } },
        }, .{
            .required_features = .{ .fast_imm16, null, null, null },
            .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mut_gpr, .none, .none } },
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .@"and", .dst0w, .ua(.src0, .add_umax), ._, ._ },
            } },
        }, .{
            .src_constraints = .{ .{ .exact_int = 32 }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .mut_mem, .none, .none } },
                .{ .src = .{ .to_mut_gpr, .none, .none } },
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .each = .{ .once = &.{} },
        }, .{
            .src_constraints = .{ .{ .signed_int = .dword }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mut_gpr, .none, .none } },
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._l, .sa, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ },
                .{ ._, ._r, .sa, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ },
            } },
        }, .{
            .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .mut_mem, .none, .none } },
                .{ .src = .{ .to_mut_gpr, .none, .none } },
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .@"and", .dst0d, .ua(.src0, .add_umax), ._, ._ },
            } },
        }, .{
            .required_features = .{ .@"64bit", null, null, null },
            .src_constraints = .{ .{ .exact_int = 64 }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .mut_mem, .none, .none } },
                .{ .src = .{ .to_mut_gpr, .none, .none } },
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .each = .{ .once = &.{} },
        }, .{
            .required_features = .{ .@"64bit", null, null, null },
            .src_constraints = .{ .{ .signed_int = .qword }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mut_gpr, .none, .none } },
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._l, .sa, .dst0q, .uia(64, .src0, .sub_bit_size), ._, ._ },
                .{ ._, ._r, .sa, .dst0q, .uia(64, .src0, .sub_bit_size), ._, ._ },
            } },
        }, .{
            .required_features = .{ .@"64bit", .bmi2, null, null },
            .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .mem, .none, .none } },
                .{ .src = .{ .to_gpr, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_bit_size), ._, ._ },
                .{ ._, ._, .bzhi, .dst0q, .src0q, .tmp0q, ._ },
            } },
        }, .{
            .required_features = .{ .@"64bit", null, null, null },
            .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .mut_mem, .none, .none } },
                .{ .src = .{ .to_mut_gpr, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ },
                .{ ._, ._, .@"and", .dst0q, .tmp0q, ._, ._ },
            } },
        }, .{
            .src_constraints = .{ .{ .exact_remainder_int = .{ .of = .xword, .is = 128 } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mut_mem, .none, .none } },
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .each = .{ .once = &.{} },
        }, .{
            .required_features = .{ .@"64bit", null, null, null },
            .src_constraints = .{ .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 64 } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mut_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0q, .memad(.src0q, .add_size, -16), ._, ._ },
                .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ },
            } },
        }, .{
            .required_features = .{ .@"64bit", null, null, null },
            .src_constraints = .{ .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mut_mem, .none, .none } },
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ },
            } },
        }, .{
            .required_features = .{ .@"64bit", null, null, null },
            .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mut_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0q, .memad(.src0q, .add_size, -16), ._, ._ },
                .{ ._, ._l, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                .{ ._, ._r, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp0q, ._, ._ },
                .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
                .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ },
            } },
        }, .{
            .required_features = .{ .@"64bit", null, null, null },
            .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mut_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ },
                .{ ._, ._, .@"and", .memad(.dst0q, .add_size, -16), .tmp0q, ._, ._ },
                .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ },
            } },
        }, .{
            .required_features = .{ .@"64bit", null, null, null },
            .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mut_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0q, .memad(.src0q, .add_size, -8), ._, ._ },
                .{ ._, ._l, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                .{ ._, ._r, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ },
            } },
        }, .{
            .required_features = .{ .@"64bit", null, null, null },
            .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mut_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ },
                .{ ._, ._, .@"and", .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ },
            } },
        }, .{
            .required_features = .{ .sse, null, null, null },
            .src_constraints = .{ .{ .scalar_exact_int = .{ .of = .xword, .is = 8 } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .mut_mem, .none, .none } },
                .{ .src = .{ .to_mut_sse, .none, .none } },
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .each = .{ .once = &.{} },
        }, .{
            .required_features = .{ .avx, null, null, null },
            .src_constraints = .{ .{ .scalar_exact_int = .{ .of = .yword, .is = 8 } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .mut_mem, .none, .none } },
                .{ .src = .{ .to_mut_sse, .none, .none } },
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .each = .{ .once = &.{} },
        }, .{
            .required_features = .{ .avx, null, null, null },
            .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_sse, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ },
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                .{ ._, .vp_b, .add, .dst0x, .dst0x, .lea(.tmp0x), ._ },
                .{ ._, .vp_, .xor, .dst0x, .dst0x, .lea(.tmp0x), ._ },
            } },
        }, .{
            .required_features = .{ .avx, null, null, null },
            .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_sse, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ },
            } },
        }, .{
            .required_features = .{ .sse2, null, null, null },
            .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mut_sse, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                .{ ._, .p_b, .add, .dst0x, .lea(.tmp0x), ._, ._ },
                .{ ._, .p_, .xor, .dst0x, .lea(.tmp0x), ._, ._ },
            } },
        }, .{
            .required_features = .{ .sse2, null, null, null },
            .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mut_sse, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
            } },
        }, .{
            .required_features = .{ .sse, null, null, null },
            .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mut_sse, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                .{ ._, ._ps, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
            } },
        }, .{
            .required_features = .{ .avx2, null, null, null },
            .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .yword, .is = .byte } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_sse, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                .{ ._, .vp_b, .add, .dst0y, .dst0y, .lea(.tmp0y), ._ },
                .{ ._, .vp_, .xor, .dst0y, .dst0y, .lea(.tmp0y), ._ },
            } },
        }, .{
            .required_features = .{ .avx2, null, null, null },
            .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_sse, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
            } },
        }, .{
            .src_constraints = .{ .{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mut_mem, .none, .none } },
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .each = .{ .once = &.{} },
        }, .{
            .required_features = .{ .avx2, null, null, null },
            .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } },
                .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } },
                .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp4), ._, ._ },
                .{ ._, .v_dqa, .mov, .tmp1y, .lea(.tmp0y), ._, ._ },
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp5), ._, ._ },
                .{ ._, .v_dqa, .mov, .tmp2y, .lea(.tmp0y), ._, ._ },
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", .vp_, .@"and", .tmp3y, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._ },
                .{ ._, .vp_b, .add, .tmp3y, .tmp3y, .tmp2y, ._ },
                .{ ._, .vp_, .xor, .tmp3y, .tmp3y, .tmp2y, ._ },
                .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp3y, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .avx2, null, null, null },
            .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                .{ ._, .v_dqa, .mov, .tmp1y, .lea(.tmp0y), ._, ._ },
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", .vp_, .@"and", .tmp2y, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._ },
                .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp2y, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .avx, null, null, null },
            .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp4), ._, ._ },
                .{ ._, .v_dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ },
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp5), ._, ._ },
                .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", .vp_, .@"and", .tmp3x, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._ },
                .{ ._, .vp_b, .add, .tmp3x, .tmp3x, .tmp2x, ._ },
                .{ ._, .vp_, .xor, .tmp3x, .tmp3x, .tmp2x, ._ },
                .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .avx, null, null, null },
            .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                .{ ._, .v_dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ },
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", .vp_, .@"and", .tmp2x, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._ },
                .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .sse2, null, null, null },
            .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp4), ._, ._ },
                .{ ._, ._dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ },
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp5), ._, ._ },
                .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._dqa, .mov, .tmp3x, .tmp1x, ._, ._ },
                .{ ._, .p_, .@"and", .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, .p_b, .add, .tmp3x, .tmp2x, ._, ._ },
                .{ ._, .p_, .xor, .tmp3x, .tmp2x, ._, ._ },
                .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .sse2, null, null, null },
            .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                .{ ._, ._dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ },
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ },
                .{ ._, .p_, .@"and", .tmp2x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .sse, null, null, null },
            .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                .{ ._, ._ps, .mova, .tmp1x, .lea(.tmp0x), ._, ._ },
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._ps, .mova, .tmp2x, .tmp1x, ._, ._ },
                .{ ._, ._ps, .@"and", .tmp2x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .slow_incdec, null, null, null },
            .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._l, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ },
                .{ ._, ._r, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ },
                .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .i8, .kind = .{ .rc = .general_purpose } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._l, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ },
                .{ ._, ._r, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ },
                .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .slow_incdec, null, null, null },
            .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._, .@"and", .tmp1b, .sa(.dst0, .add_umax), ._, ._ },
                .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._, .@"and", .tmp1b, .sa(.dst0, .add_umax), ._, ._ },
                .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .sse, null, null, null },
            .src_constraints = .{ .{ .scalar_exact_int = .{ .of = .xword, .is = 16 } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .mut_mem, .none, .none } },
                .{ .src = .{ .to_mut_sse, .none, .none } },
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .each = .{ .once = &.{} },
        }, .{
            .required_features = .{ .avx, null, null, null },
            .src_constraints = .{ .{ .scalar_exact_int = .{ .of = .yword, .is = 16 } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .mut_mem, .none, .none } },
                .{ .src = .{ .to_mut_sse, .none, .none } },
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .each = .{ .once = &.{} },
        }, .{
            .required_features = .{ .avx, null, null, null },
            .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_sse, .none, .none } },
            },
            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
            .each = .{ .once = &.{
                .{ ._, .vp_w, .sll, .dst0x, .src0x, .uia(16, .dst0, .sub_bit_size), ._ },
                .{ ._, .vp_w, .sra, .dst0x, .dst0x, .uia(16, .dst0, .sub_bit_size), ._ },
            } },
        }, .{
            .required_features = .{ .avx, null, null, null },
            .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_sse, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ },
            } },
        }, .{
            .required_features = .{ .sse2, null, null, null },
            .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mut_sse, .none, .none } },
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .each = .{ .once = &.{
                .{ ._, .p_w, .sll, .dst0x, .uia(16, .dst0, .sub_bit_size), ._, ._ },
                .{ ._, .p_w, .sra, .dst0x, .uia(16, .dst0, .sub_bit_size), ._, ._ },
            } },
        }, .{
            .required_features = .{ .sse2, null, null, null },
            .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mut_sse, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
            } },
        }, .{
            .required_features = .{ .sse, null, null, null },
            .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mut_sse, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                .{ ._, ._ps, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
            } },
        }, .{
            .required_features = .{ .avx2, null, null, null },
            .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .yword, .is = .word } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_sse, .none, .none } },
            },
            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
            .each = .{ .once = &.{
                .{ ._, .vp_w, .sll, .dst0y, .src0y, .uia(16, .dst0, .sub_bit_size), ._ },
                .{ ._, .vp_w, .sra, .dst0y, .dst0y, .uia(16, .dst0, .sub_bit_size), ._ },
            } },
        }, .{
            .required_features = .{ .avx2, null, null, null },
            .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .yword, .is = .word } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_sse, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
            } },
        }, .{
            .src_constraints = .{ .{ .multiple_scalar_exact_int = .{ .of = .word, .is = 16 } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mut_mem, .none, .none } },
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .each = .{ .once = &.{} },
        }, .{
            .required_features = .{ .avx2, null, null, null },
            .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, .vp_w, .sll, .tmp1y, .tmp1y, .uia(16, .dst0, .sub_bit_size), ._ },
                .{ ._, .vp_w, .sra, .tmp1y, .tmp1y, .uia(16, .dst0, .sub_bit_size), ._ },
                .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .avx2, null, null, null },
            .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .word } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
                .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                .{ ._, .v_dqa, .mov, .tmp1y, .lea(.tmp0y), ._, ._ },
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", .vp_, .@"and", .tmp2y, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._ },
                .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp2y, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .avx, null, null, null },
            .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, .vp_w, .sll, .tmp1x, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._ },
                .{ ._, .vp_w, .sra, .tmp1x, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._ },
                .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .avx, null, null, null },
            .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                .{ ._, .v_dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ },
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", .vp_, .@"and", .tmp2x, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._ },
                .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .sse2, null, null, null },
            .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, .p_w, .sll, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._, ._ },
                .{ ._, .p_w, .sra, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._, ._ },
                .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .sse2, null, null, null },
            .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                .{ ._, ._dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ },
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ },
                .{ ._, .p_, .@"and", .tmp2x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .sse, null, null, null },
            .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                .{ ._, ._ps, .mova, .tmp1x, .lea(.tmp0x), ._, ._ },
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._ps, .mova, .tmp2x, .tmp1x, ._, ._ },
                .{ ._, ._ps, .@"and", .tmp2x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .i16, .kind = .{ .rc = .general_purpose } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._l, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                .{ ._, ._r, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .fast_imm16, null, null, null },
            .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._, .@"and", .tmp1w, .sa(.dst0, .add_umax), ._, ._ },
                .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._, .@"and", .tmp1d, .sa(.dst0, .add_umax), ._, ._ },
                .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .sse, null, null, null },
            .src_constraints = .{ .{ .scalar_exact_int = .{ .of = .xword, .is = 32 } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .mut_mem, .none, .none } },
                .{ .src = .{ .to_mut_sse, .none, .none } },
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .each = .{ .once = &.{} },
        }, .{
            .required_features = .{ .avx, null, null, null },
            .src_constraints = .{ .{ .scalar_exact_int = .{ .of = .yword, .is = 32 } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .mut_mem, .none, .none } },
                .{ .src = .{ .to_mut_sse, .none, .none } },
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .each = .{ .once = &.{} },
        }, .{
            .required_features = .{ .avx, null, null, null },
            .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_sse, .none, .none } },
            },
            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
            .each = .{ .once = &.{
                .{ ._, .vp_d, .sll, .dst0x, .src0x, .uia(32, .dst0, .sub_bit_size), ._ },
                .{ ._, .vp_d, .sra, .dst0x, .dst0x, .uia(32, .dst0, .sub_bit_size), ._ },
            } },
        }, .{
            .required_features = .{ .avx, null, null, null },
            .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_sse, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ },
            } },
        }, .{
            .required_features = .{ .sse2, null, null, null },
            .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mut_sse, .none, .none } },
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .each = .{ .once = &.{
                .{ ._, .p_d, .sll, .dst0x, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                .{ ._, .p_d, .sra, .dst0x, .uia(32, .dst0, .sub_bit_size), ._, ._ },
            } },
        }, .{
            .required_features = .{ .sse2, null, null, null },
            .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mut_sse, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
            } },
        }, .{
            .required_features = .{ .sse, null, null, null },
            .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mut_sse, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                .{ ._, ._ps, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
            } },
        }, .{
            .required_features = .{ .avx2, null, null, null },
            .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_sse, .none, .none } },
            },
            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
            .each = .{ .once = &.{
                .{ ._, .vp_d, .sll, .dst0y, .src0y, .uia(32, .dst0, .sub_bit_size), ._ },
                .{ ._, .vp_d, .sra, .dst0y, .dst0y, .uia(32, .dst0, .sub_bit_size), ._ },
            } },
        }, .{
            .required_features = .{ .avx2, null, null, null },
            .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_sse, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
            } },
        }, .{
            .required_features = .{ .avx2, null, null, null },
            .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, .vp_d, .sll, .tmp1y, .tmp1y, .uia(32, .dst0, .sub_bit_size), ._ },
                .{ ._, .vp_d, .sra, .tmp1y, .tmp1y, .uia(32, .dst0, .sub_bit_size), ._ },
                .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .avx2, null, null, null },
            .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
                .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                .{ ._, .v_dqa, .mov, .tmp1y, .lea(.tmp0y), ._, ._ },
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", .vp_, .@"and", .tmp2y, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._ },
                .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp2y, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .avx, null, null, null },
            .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, .vp_d, .sll, .tmp1x, .tmp1x, .uia(32, .dst0, .sub_bit_size), ._ },
                .{ ._, .vp_d, .sra, .tmp1x, .tmp1x, .uia(32, .dst0, .sub_bit_size), ._ },
                .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .avx, null, null, null },
            .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                .{ ._, .v_dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ },
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", .vp_, .@"and", .tmp2x, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._ },
                .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .sse2, null, null, null },
            .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, .p_d, .sll, .tmp1x, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                .{ ._, .p_d, .sra, .tmp1x, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .sse2, null, null, null },
            .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                .{ ._, ._dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ },
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ },
                .{ ._, .p_, .@"and", .tmp2x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .sse, null, null, null },
            .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                .{ ._, ._ps, .mova, .tmp1x, .lea(.tmp0x), ._, ._ },
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._ps, .mova, .tmp2x, .tmp1x, ._, ._ },
                .{ ._, ._ps, .@"and", .tmp2x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .src_constraints = .{ .{ .multiple_scalar_exact_int = .{ .of = .dword, .is = 32 } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mut_mem, .none, .none } },
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .each = .{ .once = &.{} },
        }, .{
            .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._l, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                .{ ._, ._r, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ },
                .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .bmi2, null, null, null },
            .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
                .{ .@"0:", ._, .bzhi, .tmp2d, .memia(.src0d, .tmp0, .add_unaligned_size), .tmp1d, ._ },
                .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._, .@"and", .tmp1d, .sa(.dst0, .add_umax), ._, ._ },
                .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .sse, null, null, null },
            .src_constraints = .{ .{ .scalar_exact_int = .{ .of = .xword, .is = 64 } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .mut_mem, .none, .none } },
                .{ .src = .{ .to_mut_sse, .none, .none } },
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .each = .{ .once = &.{} },
        }, .{
            .required_features = .{ .avx, null, null, null },
            .src_constraints = .{ .{ .scalar_exact_int = .{ .of = .yword, .is = 64 } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .mut_mem, .none, .none } },
                .{ .src = .{ .to_mut_sse, .none, .none } },
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .each = .{ .once = &.{} },
        }, .{
            .required_features = .{ .avx, null, null, null },
            .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_sse, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ },
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                .{ ._, .vp_q, .add, .dst0x, .dst0x, .lea(.tmp0x), ._ },
                .{ ._, .vp_, .xor, .dst0x, .dst0x, .lea(.tmp0x), ._ },
            } },
        }, .{
            .required_features = .{ .avx, null, null, null },
            .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_sse, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ },
            } },
        }, .{
            .required_features = .{ .sse2, null, null, null },
            .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mut_sse, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                .{ ._, .p_q, .add, .dst0x, .lea(.tmp0x), ._, ._ },
                .{ ._, .p_, .xor, .dst0x, .lea(.tmp0x), ._, ._ },
            } },
        }, .{
            .required_features = .{ .sse2, null, null, null },
            .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mut_sse, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
            } },
        }, .{
            .required_features = .{ .sse, null, null, null },
            .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mut_sse, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                .{ ._, ._ps, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
            } },
        }, .{
            .required_features = .{ .avx2, null, null, null },
            .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_sse, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
                .{ ._, .vp_q, .add, .dst0y, .dst0y, .lea(.tmp0y), ._ },
                .{ ._, .vp_, .xor, .dst0y, .dst0y, .lea(.tmp0y), ._ },
            } },
        }, .{
            .required_features = .{ .avx2, null, null, null },
            .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_sse, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .usize, .kind = .{ .rc = .general_purpose } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
                .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
            } },
        }, .{
            .required_features = .{ .avx2, null, null, null },
            .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp4), ._, ._ },
                .{ ._, .v_dqa, .mov, .tmp1y, .lea(.tmp0y), ._, ._ },
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp5), ._, ._ },
                .{ ._, .v_dqa, .mov, .tmp2y, .lea(.tmp0y), ._, ._ },
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", .vp_, .@"and", .tmp3y, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._ },
                .{ ._, .vp_q, .add, .tmp3y, .tmp3y, .tmp2y, ._ },
                .{ ._, .vp_, .xor, .tmp3y, .tmp3y, .tmp2y, ._ },
                .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp3y, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .avx2, null, null, null },
            .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                .{ ._, .v_dqa, .mov, .tmp1y, .lea(.tmp0y), ._, ._ },
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", .vp_, .@"and", .tmp2y, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._ },
                .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp2y, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .avx, null, null, null },
            .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp4), ._, ._ },
                .{ ._, .v_dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ },
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp5), ._, ._ },
                .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", .vp_, .@"and", .tmp3x, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._ },
                .{ ._, .vp_q, .add, .tmp3x, .tmp3x, .tmp2x, ._ },
                .{ ._, .vp_, .xor, .tmp3x, .tmp3x, .tmp2x, ._ },
                .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .avx, null, null, null },
            .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                .{ ._, .v_dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ },
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", .vp_, .@"and", .tmp2x, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._ },
                .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .sse2, null, null, null },
            .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp4), ._, ._ },
                .{ ._, ._dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ },
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp5), ._, ._ },
                .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._dqa, .mov, .tmp3x, .tmp1x, ._, ._ },
                .{ ._, .p_, .@"and", .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, .p_q, .add, .tmp3x, .tmp2x, ._, ._ },
                .{ ._, .p_, .xor, .tmp3x, .tmp2x, ._, ._ },
                .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .sse2, null, null, null },
            .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                .{ ._, ._dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ },
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ },
                .{ ._, .p_, .@"and", .tmp2x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .sse, null, null, null },
            .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
                .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ },
                .{ ._, ._ps, .mova, .tmp1x, .lea(.tmp0x), ._, ._ },
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._ps, .mova, .tmp2x, .tmp1x, ._, ._ },
                .{ ._, ._ps, .@"and", .tmp2x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .src_constraints = .{ .{ .multiple_scalar_exact_int = .{ .of = .qword, .is = 64 } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mut_mem, .none, .none } },
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .each = .{ .once = &.{} },
        }, .{
            .required_features = .{ .@"64bit", null, null, null },
            .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._l, .sa, .tmp1q, .uia(64, .dst0, .sub_bit_size), ._, ._ },
                .{ ._, ._r, .sa, .tmp1q, .uia(64, .dst0, .sub_bit_size), ._, ._ },
                .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .@"64bit", .bmi2, null, null },
            .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
                .{ .@"0:", ._, .bzhi, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), .tmp1q, ._ },
                .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .@"64bit", null, null, null },
            .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._, .mov, .tmp1q, .ua(.dst0, .add_umax), ._, ._ },
                .{ ._, ._, .@"and", .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .sse, null, null, null },
            .src_constraints = .{ .{ .scalar_exact_int = .{ .of = .xword, .is = 128 } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .mut_mem, .none, .none } },
                .{ .src = .{ .to_mut_sse, .none, .none } },
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .each = .{ .once = &.{} },
        }, .{
            .required_features = .{ .avx, null, null, null },
            .src_constraints = .{ .{ .scalar_exact_int = .{ .of = .yword, .is = 128 } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .mut_mem, .none, .none } },
                .{ .src = .{ .to_mut_sse, .none, .none } },
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .each = .{ .once = &.{} },
        }, .{
            .src_constraints = .{ .{ .scalar_exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mut_mem, .none, .none } },
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .each = .{ .once = &.{} },
        }, .{
            .required_features = .{ .@"64bit", null, null, null },
            .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mut_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                .{ ._, ._l, .sa, .tmp1q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                .{ ._, ._r, .sa, .tmp1q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp1q, ._, ._ },
                .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
                .{ ._, ._, .mov, .memid(.dst0q, .tmp0, 8), .tmp1q, ._, ._ },
                .{ ._, ._, .sub, .tmp0d, .sa(.src0, .add_elem_size), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .@"64bit", null, null, null },
            .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mut_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
                .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ },
                .{ .@"0:", ._, .@"and", .memi(.dst0q, .tmp0), .tmp1q, ._, ._ },
                .{ ._, ._, .mov, .memid(.dst0q, .tmp0, 8), .si(0), ._, ._ },
                .{ ._, ._, .sub, .tmp0d, .sa(.src0, .add_elem_size), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .@"64bit", null, null, null },
            .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mut_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ },
                .{ ._, ._l, .sa, .tmp1q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                .{ ._, ._r, .sa, .tmp1q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ },
                .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp1q, ._, ._ },
                .{ ._, ._, .sub, .tmp0d, .sa(.src0, .add_elem_size), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .@"64bit", null, null, null },
            .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
            .patterns = &.{
                .{ .src = .{ .to_mut_mem, .none, .none } },
            },
            .extra_temps = .{
                .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
                .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ },
                .{ .@"0:", ._, .@"and", .memi(.dst0q, .tmp0), .tmp1q, ._, ._ },
                .{ ._, ._, .sub, .tmp0d, .sa(.src0, .add_elem_size), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        } });
        for (ops) |op| for (res) |r| {
            if (op.index == r.index) break;
        } else try op.die(cg);
        temp.* = res[0];
    }

    /// Supports any `op` using `cg.intInfo(lhs.typeOf(cg)).?.signedness` as the signedness.
    /// Returns `error.SelectFailed` when `cg.intInfo(lhs.typeOf(cg)) == null`.
    fn cmpInts(lhs: *Temp, op: std.math.CompareOperator, rhs: *Temp, cg: *CodeGen) Select.Error!Temp {
        var ops: [2]Temp = .{ lhs.*, rhs.* };
        var res: [1]Temp = undefined;
        switch (op) {
            .lt, .lte, .gte, .gt => {
                const commute = switch (op) {
                    .lt, .gte => false,
                    .lte, .gt => true,
                    else => unreachable,
                };
                if (commute) std.mem.swap(Temp, &ops[0], &ops[1]);
                try cg.select(&res, &.{.bool}, &ops, comptime &.{ .{
                    .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .imm8, .mem, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .imm8, .to_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .mem, .to_gpr, .none }, .commute = .{ 0, 1 } },
                    },
                    .dst_temps = .{ .{ .cc = .g }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .imm8, .none } },
                        .{ .src = .{ .to_gpr, .imm8, .none } },
                        .{ .src = .{ .to_gpr, .mem, .none } },
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .cc = .l }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .imm8, .mem, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .imm8, .to_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .mem, .to_gpr, .none }, .commute = .{ 0, 1 } },
                    },
                    .dst_temps = .{ .{ .cc = .a }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .imm8, .none } },
                        .{ .src = .{ .to_gpr, .imm8, .none } },
                        .{ .src = .{ .to_gpr, .mem, .none } },
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .cc = .b }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .imm16, .mem, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .imm16, .to_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .mem, .to_gpr, .none }, .commute = .{ 0, 1 } },
                    },
                    .dst_temps = .{ .{ .cc = .g }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .imm16, .none } },
                        .{ .src = .{ .to_gpr, .imm16, .none } },
                        .{ .src = .{ .to_gpr, .mem, .none } },
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .cc = .l }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .imm16, .mem, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .imm16, .to_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .mem, .to_gpr, .none }, .commute = .{ 0, 1 } },
                    },
                    .dst_temps = .{ .{ .cc = .a }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .imm16, .none } },
                        .{ .src = .{ .to_gpr, .imm16, .none } },
                        .{ .src = .{ .to_gpr, .mem, .none } },
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .cc = .b }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .imm32, .mem, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .imm32, .to_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .mem, .to_gpr, .none }, .commute = .{ 0, 1 } },
                    },
                    .dst_temps = .{ .{ .cc = .g }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .imm32, .none } },
                        .{ .src = .{ .to_gpr, .imm32, .none } },
                        .{ .src = .{ .to_gpr, .mem, .none } },
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .cc = .l }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .imm32, .mem, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .imm32, .to_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .mem, .to_gpr, .none }, .commute = .{ 0, 1 } },
                    },
                    .dst_temps = .{ .{ .cc = .a }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .imm32, .none } },
                        .{ .src = .{ .to_gpr, .imm32, .none } },
                        .{ .src = .{ .to_gpr, .mem, .none } },
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .cc = .b }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .simm32, .mem, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .simm32, .to_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .mem, .to_gpr, .none }, .commute = .{ 0, 1 } },
                    },
                    .dst_temps = .{ .{ .cc = .g }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .simm32, .none } },
                        .{ .src = .{ .to_gpr, .simm32, .none } },
                        .{ .src = .{ .to_gpr, .mem, .none } },
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .cc = .l }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .simm32, .mem, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .simm32, .to_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .mem, .to_gpr, .none }, .commute = .{ 0, 1 } },
                    },
                    .dst_temps = .{ .{ .cc = .a }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .simm32, .none } },
                        .{ .src = .{ .to_gpr, .simm32, .none } },
                        .{ .src = .{ .to_gpr, .mem, .none } },
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .cc = .b }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } },
                        .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .cc = .l }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -8), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } },
                        .{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .cc = .b }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_8), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memsia(.src1q, .@"8", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } },
                        .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .i32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .cc = .l }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_4), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"4", .tmp0, .add_size, -4), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"4", .tmp0, .add_size, -4), ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -4), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -4), ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } },
                        .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .cc = .b }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_4), ._, ._ },
                        .{ ._, ._c, .cl, ._, ._, ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .sbb, .tmp1q, .memsia(.src1q, .@"4", .tmp0, .add_size), ._, ._ },
                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                } });
                if (commute) std.mem.swap(Temp, &ops[0], &ops[1]);
            },
            .eq, .neq => {
                try cg.select(&res, &.{.bool}, &ops, comptime &.{ .{
                    .src_constraints = .{ .{ .int = .byte }, .{ .int = .byte }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .imm8, .none } },
                        .{ .src = .{ .imm8, .mem, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_gpr, .imm8, .none } },
                        .{ .src = .{ .imm8, .to_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .cc = .e }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .int = .word }, .{ .int = .word }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .imm16, .none } },
                        .{ .src = .{ .imm16, .mem, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_gpr, .imm16, .none } },
                        .{ .src = .{ .imm16, .to_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .cc = .e }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{ .{ .int = .dword }, .{ .int = .dword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .imm32, .none } },
                        .{ .src = .{ .imm32, .mem, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_gpr, .imm32, .none } },
                        .{ .src = .{ .imm32, .to_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .cc = .e }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{ .{ .int = .qword }, .{ .int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .mem, .simm32, .none } },
                        .{ .src = .{ .simm32, .mem, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_gpr, .simm32, .none } },
                        .{ .src = .{ .simm32, .to_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_gpr, .mem, .none } },
                        .{ .src = .{ .mem, .to_gpr, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
                    },
                    .dst_temps = .{ .{ .cc = .e }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, .mmx, null, null },
                    .src_constraints = .{ .{ .int = .qword }, .{ .int = .qword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_mmx, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_mmx, .to_mmx, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .rc = .mmx } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .cc = .z }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .p_, .xor, .tmp1q, .tmp1q, ._, ._ },
                        .{ ._, .p_, .xor, .src0q, .src1q, ._, ._ },
                        .{ ._, .p_b, .cmpeq, .tmp1q, .src0q, ._, ._ },
                        .{ ._, .p_b, .movmsk, .tmp0d, .tmp1q, ._, ._ },
                        .{ ._, ._, .cmp, .tmp0b, .si(-1), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .int = .xword }, .{ .int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .cc = .z }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .vp_, .xor, .tmp0x, .src0x, .src1x, ._ },
                        .{ ._, .vp_, .@"test", .tmp0x, .tmp0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{ .{ .int = .xword }, .{ .int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .dst_temps = .{ .{ .cc = .z }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .p_, .xor, .src0x, .src1x, ._, ._ },
                        .{ ._, .p_, .@"test", .src0x, .src0x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, .fast_imm16, null, null },
                    .src_constraints = .{ .{ .int = .xword }, .{ .int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .cc = .z }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_, .xor, .src0x, .src1x, ._, ._ },
                        .{ ._, .p_b, .cmpeq, .tmp1x, .src0x, ._, ._ },
                        .{ ._, .p_b, .movmsk, .tmp0d, .tmp1x, ._, ._ },
                        .{ ._, ._, .cmp, .tmp0w, .si(-1), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{ .{ .int = .xword }, .{ .int = .xword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_mut_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .cc = .z }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, .p_, .xor, .src0x, .src1x, ._, ._ },
                        .{ ._, .p_b, .cmpeq, .tmp1x, .src0x, ._, ._ },
                        .{ ._, .p_b, .movmsk, .tmp0d, .tmp1x, ._, ._ },
                        .{ ._, ._, .xor, .tmp0d, .si(std.math.maxInt(u16)), ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{ .{ .int = .yword }, .{ .int = .yword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .cc = .z }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .vp_, .xor, .tmp0y, .src0y, .src1y, ._ },
                        .{ ._, .vp_, .@"test", .tmp0y, .tmp0y, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{ .{ .int = .yword }, .{ .int = .yword }, .any },
                    .patterns = &.{
                        .{ .src = .{ .to_sse, .mem, .none } },
                        .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
                        .{ .src = .{ .to_sse, .to_sse, .none } },
                    },
                    .extra_temps = .{
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .cc = .z }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, .v_pd, .xor, .tmp0y, .src0y, .src1y, ._ },
                        .{ ._, .vp_, .@"test", .tmp0y, .tmp0y, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .remainder_int = .{ .of = .yword, .is = .xword } },
                        .{ .remainder_int = .{ .of = .yword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .cc = .z }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_dqu, .mov, .tmp1y, .memiad(.src0y, .tmp0, .add_size, -16), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp1y, .tmp1y, .memiad(.src1y, .tmp0, .add_size, -16), ._ },
                        .{ ._, .vp_, .@"test", .tmp1y, .tmp1y, ._, ._ },
                        .{ ._, ._nz, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, .v_dqa, .mov, .tmp1x, .memad(.src0x, .add_size, -16), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp1x, .tmp1x, .memad(.src1x, .add_size, -16), ._ },
                        .{ ._, .vp_, .@"test", .tmp1x, .tmp1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .remainder_int = .{ .of = .yword, .is = .xword } },
                        .{ .remainder_int = .{ .of = .yword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .cc = .z }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_pd, .movu, .tmp1y, .memiad(.src0y, .tmp0, .add_size, -16), ._, ._ },
                        .{ ._, .v_pd, .xor, .tmp1y, .tmp1y, .memiad(.src1y, .tmp0, .add_size, -16), ._ },
                        .{ ._, .vp_, .@"test", .tmp1y, .tmp1y, ._, ._ },
                        .{ ._, ._nz, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                        .{ ._, .v_pd, .mova, .tmp1x, .memad(.src0x, .add_size, -16), ._, ._ },
                        .{ ._, .v_pd, .xor, .tmp1x, .tmp1x, .memad(.src1x, .add_size, -16), ._ },
                        .{ ._, .vp_, .@"test", .tmp1x, .tmp1x, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx2, null, null, null },
                    .src_constraints = .{
                        .{ .remainder_int = .{ .of = .yword, .is = .yword } },
                        .{ .remainder_int = .{ .of = .yword, .is = .yword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .cc = .z }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_dqu, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_size), ._ },
                        .{ ._, .vp_, .@"test", .tmp1y, .tmp1y, ._, ._ },
                        .{ ._, ._nz, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .remainder_int = .{ .of = .yword, .is = .yword } },
                        .{ .remainder_int = .{ .of = .yword, .is = .yword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .cc = .z }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_pd, .movu, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ },
                        .{ ._, .v_pd, .xor, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_size), ._ },
                        .{ ._, .vp_, .@"test", .tmp1y, .tmp1y, ._, ._ },
                        .{ ._, ._nz, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .avx, null, null, null },
                    .src_constraints = .{
                        .{ .remainder_int = .{ .of = .xword, .is = .xword } },
                        .{ .remainder_int = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .cc = .z }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .vp_, .xor, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._ },
                        .{ ._, .vp_, .@"test", .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._nz, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse4_1, null, null, null },
                    .src_constraints = .{
                        .{ .remainder_int = .{ .of = .xword, .is = .xword } },
                        .{ .remainder_int = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .rc = .sse } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .cc = .z }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .p_, .xor, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .p_, .@"test", .tmp1x, .tmp1x, ._, ._ },
                        .{ ._, ._nz, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, .fast_imm16, null, null },
                    .src_constraints = .{
                        .{ .remainder_int = .{ .of = .xword, .is = .xword } },
                        .{ .remainder_int = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .rc = .sse } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .cc = .z }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .p_b, .cmpeq, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .p_b, .movmsk, .tmp2d, .tmp1x, ._, ._ },
                        .{ ._, ._, .cmp, .tmp2w, .si(-1), ._, ._ },
                        .{ ._, ._nz, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse2, null, null, null },
                    .src_constraints = .{
                        .{ .remainder_int = .{ .of = .xword, .is = .xword } },
                        .{ .remainder_int = .{ .of = .xword, .is = .xword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .rc = .sse } },
                        .{ .type = .u16, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .cc = .z }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .p_b, .cmpeq, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ },
                        .{ ._, .p_b, .movmsk, .tmp2d, .tmp1x, ._, ._ },
                        .{ ._, ._, .xor, .tmp2d, .si(std.math.maxInt(u16)), ._, ._ },
                        .{ ._, ._nz, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .sse, .mmx, null, null },
                    .src_constraints = .{
                        .{ .remainder_int = .{ .of = .qword, .is = .qword } },
                        .{ .remainder_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .kind = .{ .rc = .mmx } },
                        .{ .type = .u8, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .cc = .z }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._q, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ },
                        .{ ._, .p_b, .cmpeq, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ },
                        .{ ._, .p_b, .movmsk, .tmp2d, .tmp1q, ._, ._ },
                        .{ ._, ._, .cmp, .tmp2b, .si(-1), ._, ._ },
                        .{ ._, ._nz, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .required_features = .{ .@"64bit", null, null, null },
                    .src_constraints = .{
                        .{ .remainder_int = .{ .of = .qword, .is = .qword } },
                        .{ .remainder_int = .{ .of = .qword, .is = .qword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u64, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .cc = .z }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._nz, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                }, .{
                    .src_constraints = .{
                        .{ .remainder_int = .{ .of = .dword, .is = .dword } },
                        .{ .remainder_int = .{ .of = .dword, .is = .dword } },
                        .any,
                    },
                    .patterns = &.{
                        .{ .src = .{ .to_mem, .to_mem, .none } },
                    },
                    .extra_temps = .{
                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                        .{ .type = .u32, .kind = .{ .rc = .general_purpose } },
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                        .unused,
                    },
                    .dst_temps = .{ .{ .cc = .z }, .unused },
                    .clobbers = .{ .eflags = true },
                    .each = .{ .once = &.{
                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._, .xor, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ },
                        .{ ._, ._nz, .j, .@"0f", ._, ._, ._ },
                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
                    } },
                } });
            },
        }
        if (switch (op) {
            .lt, .gt, .eq => false,
            .lte, .gte, .neq => true,
        }) {
            const cc = &res[0].unwrap(cg).temp.tracking(cg).short.eflags;
            cc.* = cc.negate();
        }
        lhs.*, rhs.* = ops;
        return res[0];
    }

    fn divTruncInts(lhs: *Temp, rhs: *Temp, cg: *CodeGen) Select.Error!Temp {
        var ops: [2]Temp = .{ lhs.*, rhs.* };
        var res: [1]Temp = undefined;
        try cg.select(&res, &.{lhs.typeOf(cg)}, &ops, comptime &.{ .{
            .src_constraints = .{ .{ .exact_signed_int = 1 }, .{ .exact_signed_int = 1 }, .any },
            .patterns = &.{
                .{ .src = .{ .any, .any, .none } },
            },
            .dst_temps = .{ .{ .imm = 0 }, .unused },
            .each = .{ .once = &.{} },
        }, .{
            .src_constraints = .{ .{ .exact_unsigned_int = 1 }, .{ .exact_unsigned_int = 1 }, .any },
            .patterns = &.{
                .{ .src = .{ .mut_mem, .any, .none } },
                .{ .src = .{ .to_mut_gpr, .any, .none } },
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .each = .{ .once = &.{} },
        }, .{
            .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any },
            .patterns = &.{
                .{ .src = .{ .mem, .mem, .none } },
                .{ .src = .{ .to_gpr, .mem, .none } },
                .{ .src = .{ .mem, .to_gpr, .none } },
                .{ .src = .{ .to_gpr, .to_gpr, .none } },
            },
            .dst_temps = .{ .{ .reg = .al }, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .movsx, .dst0d, .src0b, ._, ._ },
                .{ ._, .i_, .div, .src1b, ._, ._, ._ },
            } },
        }, .{
            .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any },
            .patterns = &.{
                .{ .src = .{ .mem, .mem, .none } },
                .{ .src = .{ .to_gpr, .mem, .none } },
                .{ .src = .{ .mem, .to_gpr, .none } },
                .{ .src = .{ .to_gpr, .to_gpr, .none } },
            },
            .dst_temps = .{ .{ .reg = .al }, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .movzx, .dst0d, .src0b, ._, ._ },
                .{ ._, ._, .div, .src1b, ._, ._, ._ },
            } },
        }, .{
            .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
            .patterns = &.{
                .{ .src = .{ .{ .to_reg = .ax }, .mem, .none } },
                .{ .src = .{ .{ .to_reg = .ax }, .to_gpr, .none } },
            },
            .extra_temps = .{
                .{ .type = .i16, .kind = .{ .reg = .dx } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .cwd, ._, ._, ._, ._ },
                .{ ._, .i_, .div, .src1w, ._, ._, ._ },
            } },
        }, .{
            .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any },
            .patterns = &.{
                .{ .src = .{ .{ .to_reg = .ax }, .mem, .none } },
                .{ .src = .{ .{ .to_reg = .ax }, .to_gpr, .none } },
            },
            .extra_temps = .{
                .{ .type = .u16, .kind = .{ .reg = .dx } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                .{ ._, ._, .div, .src1w, ._, ._, ._ },
            } },
        }, .{
            .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any },
            .patterns = &.{
                .{ .src = .{ .{ .to_reg = .eax }, .mem, .none } },
                .{ .src = .{ .{ .to_reg = .eax }, .to_gpr, .none } },
            },
            .extra_temps = .{
                .{ .type = .i32, .kind = .{ .reg = .edx } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .cdq, ._, ._, ._, ._ },
                .{ ._, .i_, .div, .src1d, ._, ._, ._ },
            } },
        }, .{
            .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any },
            .patterns = &.{
                .{ .src = .{ .{ .to_reg = .eax }, .mem, .none } },
                .{ .src = .{ .{ .to_reg = .eax }, .to_gpr, .none } },
            },
            .extra_temps = .{
                .{ .type = .u32, .kind = .{ .reg = .edx } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
                .{ ._, ._, .div, .src1d, ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .@"64bit", null, null, null },
            .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any },
            .patterns = &.{
                .{ .src = .{ .{ .to_reg = .rax }, .mem, .none } },
                .{ .src = .{ .{ .to_reg = .rax }, .to_gpr, .none } },
            },
            .extra_temps = .{
                .{ .type = .i64, .kind = .{ .reg = .rdx } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .cqo, ._, ._, ._, ._ },
                .{ ._, .i_, .div, .src1q, ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .@"64bit", null, null, null },
            .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any },
            .patterns = &.{
                .{ .src = .{ .{ .to_reg = .rax }, .mem, .none } },
                .{ .src = .{ .{ .to_reg = .rax }, .to_gpr, .none } },
            },
            .extra_temps = .{
                .{ .type = .u64, .kind = .{ .reg = .rdx } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .ref = .src0 }, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .xor, .tmp0q, .tmp0q, ._, ._ },
                .{ ._, ._, .div, .src1q, ._, ._, ._ },
            } },
        }, .{
            .required_cc_abi = .sysv64,
            .src_constraints = .{ .{ .signed_int = .xword }, .{ .signed_int = .xword }, .any },
            .patterns = &.{
                .{ .src = .{
                    .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } },
                    .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 2, .at = 2 } },
                    .none,
                } },
            },
            .call_frame = .{ .alignment = .@"16" },
            .extra_temps = .{
                .{ .type = .usize, .kind = .{ .extern_func = "__divti3" } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
            .each = .{ .once = &.{
                .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
            } },
        }, .{
            .required_cc_abi = .win64,
            .required_features = .{ .sse, null, null, null },
            .src_constraints = .{ .{ .signed_int = .xword }, .{ .signed_int = .xword }, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .to_mem, .none } },
            },
            .call_frame = .{ .alignment = .@"16" },
            .extra_temps = .{
                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                .{ .type = .usize, .kind = .{ .extern_func = "__divti3" } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
            } },
        }, .{
            .required_cc_abi = .sysv64,
            .src_constraints = .{ .{ .unsigned_int = .xword }, .{ .unsigned_int = .xword }, .any },
            .patterns = &.{
                .{ .src = .{
                    .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } },
                    .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 2, .at = 2 } },
                    .none,
                } },
            },
            .call_frame = .{ .alignment = .@"16" },
            .extra_temps = .{
                .{ .type = .usize, .kind = .{ .extern_func = "__udivti3" } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
            .each = .{ .once = &.{
                .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
            } },
        }, .{
            .required_cc_abi = .win64,
            .required_features = .{ .sse, null, null, null },
            .src_constraints = .{ .{ .unsigned_int = .xword }, .{ .unsigned_int = .xword }, .any },
            .patterns = &.{
                .{ .src = .{ .to_mem, .to_mem, .none } },
            },
            .call_frame = .{ .alignment = .@"16" },
            .extra_temps = .{
                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                .{ .type = .usize, .kind = .{ .extern_func = "__udivti3" } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused },
            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
                .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
                .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .@"64bit", null, null, null },
            .src_constraints = .{
                .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } },
                .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } },
                .any,
            },
            .patterns = &.{
                .{ .src = .{ .to_mut_mem, .to_mut_mem, .none } },
            },
            .call_frame = .{ .alignment = .@"16" },
            .extra_temps = .{
                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
                .{ .type = .usize, .kind = .{ .extern_func = "__divei4" } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                .{ ._, ._, .lea, .tmp2p, .mem(.src1), ._, ._ },
                .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .@"64bit", null, null, null },
            .src_constraints = .{
                .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } },
                .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } },
                .any,
            },
            .patterns = &.{
                .{ .src = .{ .to_mem, .to_mem, .none } },
            },
            .call_frame = .{ .alignment = .@"16" },
            .extra_temps = .{
                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
                .{ .type = .usize, .kind = .{ .extern_func = "__udivei4" } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
            .each = .{ .once = &.{
                .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
                .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
                .{ ._, ._, .lea, .tmp2p, .mem(.src1), ._, ._ },
                .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
                .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .slow_incdec, null, null, null },
            .src_constraints = .{
                .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                .any,
            },
            .patterns = &.{
                .{ .src = .{ .to_mem, .to_mem, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .i8, .kind = .{ .reg = .al } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, .i_, .div, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ },
                .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .src_constraints = .{
                .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
                .any,
            },
            .patterns = &.{
                .{ .src = .{ .to_mem, .to_mem, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .i8, .kind = .{ .reg = .al } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, .i_, .div, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ },
                .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .slow_incdec, null, null, null },
            .src_constraints = .{
                .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                .any,
            },
            .patterns = &.{
                .{ .src = .{ .to_mem, .to_mem, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .u8, .kind = .{ .reg = .al } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._, .div, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ },
                .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .src_constraints = .{
                .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
                .any,
            },
            .patterns = &.{
                .{ .src = .{ .to_mem, .to_mem, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .u8, .kind = .{ .reg = .al } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._, .div, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ },
                .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
                .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
                .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .src_constraints = .{
                .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
                .any,
            },
            .patterns = &.{
                .{ .src = .{ .to_mem, .to_mem, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .i16, .kind = .{ .reg = .ax } },
                .{ .type = .i16, .kind = .{ .reg = .dx } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._, .cwd, ._, ._, ._, ._ },
                .{ ._, .i_, .div, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._, ._ },
                .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .src_constraints = .{
                .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } },
                .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } },
                .any,
            },
            .patterns = &.{
                .{ .src = .{ .to_mem, .to_mem, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .u16, .kind = .{ .reg = .ax } },
                .{ .type = .u16, .kind = .{ .reg = .dx } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                .{ ._, ._, .div, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._, ._ },
                .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .src_constraints = .{
                .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } },
                .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } },
                .any,
            },
            .patterns = &.{
                .{ .src = .{ .to_mem, .to_mem, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .i32, .kind = .{ .reg = .eax } },
                .{ .type = .i32, .kind = .{ .reg = .edx } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._, .cdq, ._, ._, ._, ._ },
                .{ ._, .i_, .div, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._, ._ },
                .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .src_constraints = .{
                .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } },
                .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } },
                .any,
            },
            .patterns = &.{
                .{ .src = .{ .to_mem, .to_mem, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .u32, .kind = .{ .reg = .eax } },
                .{ .type = .u32, .kind = .{ .reg = .edx } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                .{ ._, ._, .div, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._, ._ },
                .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .@"64bit", null, null, null },
            .src_constraints = .{
                .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } },
                .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } },
                .any,
            },
            .patterns = &.{
                .{ .src = .{ .to_mem, .to_mem, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .i64, .kind = .{ .reg = .rax } },
                .{ .type = .i64, .kind = .{ .reg = .rdx } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._, .cqo, ._, ._, ._, ._ },
                .{ ._, .i_, .div, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._, ._ },
                .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .@"64bit", null, null, null },
            .src_constraints = .{
                .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } },
                .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } },
                .any,
            },
            .patterns = &.{
                .{ .src = .{ .to_mem, .to_mem, .none } },
            },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .u64, .kind = .{ .reg = .rax } },
                .{ .type = .u64, .kind = .{ .reg = .rdx } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
                .{ ._, ._, .div, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._, ._ },
                .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_cc_abi = .sysv64,
            .src_constraints = .{
                .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } },
                .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } },
                .any,
            },
            .patterns = &.{
                .{ .src = .{ .to_mem, .to_mem, .none } },
            },
            .call_frame = .{ .alignment = .@"16" },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
                .{ .type = .usize, .kind = .{ .extern_func = "__divti3" } },
                .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ },
                .{ ._, ._, .mov, .tmp3q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._, .mov, .tmp4q, .memiad(.src1q, .tmp0, .add_unaligned_size, 8), ._, ._ },
                .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp6q, ._, ._ },
                .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp3q, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_cc_abi = .win64,
            .required_features = .{ .avx, null, null, null },
            .src_constraints = .{
                .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } },
                .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } },
                .any,
            },
            .patterns = &.{
                .{ .src = .{ .to_mem, .to_mem, .none } },
            },
            .call_frame = .{ .alignment = .@"16" },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                .{ .type = .usize, .kind = .{ .extern_func = "__divti3" } },
                .{ .type = .i128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._, .lea, .tmp2p, .memia(.src1, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_cc_abi = .win64,
            .required_features = .{ .sse2, null, null, null },
            .src_constraints = .{
                .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } },
                .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } },
                .any,
            },
            .patterns = &.{
                .{ .src = .{ .to_mem, .to_mem, .none } },
            },
            .call_frame = .{ .alignment = .@"16" },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                .{ .type = .usize, .kind = .{ .extern_func = "__divti3" } },
                .{ .type = .i128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._, .lea, .tmp2p, .memia(.src1, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_cc_abi = .win64,
            .required_features = .{ .sse, null, null, null },
            .src_constraints = .{
                .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } },
                .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } },
                .any,
            },
            .patterns = &.{
                .{ .src = .{ .to_mem, .to_mem, .none } },
            },
            .call_frame = .{ .alignment = .@"16" },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                .{ .type = .usize, .kind = .{ .extern_func = "__divti3" } },
                .{ .type = .i128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._, .lea, .tmp2p, .memia(.src1, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_cc_abi = .sysv64,
            .src_constraints = .{
                .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } },
                .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } },
                .any,
            },
            .patterns = &.{
                .{ .src = .{ .to_mem, .to_mem, .none } },
            },
            .call_frame = .{ .alignment = .@"16" },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
                .{ .type = .usize, .kind = .{ .extern_func = "__udivti3" } },
                .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ },
                .{ ._, ._, .mov, .tmp3q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._, .mov, .tmp4q, .memiad(.src1q, .tmp0, .add_unaligned_size, 8), ._, ._ },
                .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp6q, ._, ._ },
                .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp3q, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_cc_abi = .win64,
            .required_features = .{ .avx, null, null, null },
            .src_constraints = .{
                .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } },
                .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } },
                .any,
            },
            .patterns = &.{
                .{ .src = .{ .to_mem, .to_mem, .none } },
            },
            .call_frame = .{ .alignment = .@"16" },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                .{ .type = .usize, .kind = .{ .extern_func = "__udivti3" } },
                .{ .type = .u128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._, .lea, .tmp2p, .memia(.src1, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_cc_abi = .win64,
            .required_features = .{ .sse2, null, null, null },
            .src_constraints = .{
                .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } },
                .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } },
                .any,
            },
            .patterns = &.{
                .{ .src = .{ .to_mem, .to_mem, .none } },
            },
            .call_frame = .{ .alignment = .@"16" },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                .{ .type = .usize, .kind = .{ .extern_func = "__udivti3" } },
                .{ .type = .u128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._, .lea, .tmp2p, .memia(.src1, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_cc_abi = .win64,
            .required_features = .{ .sse, null, null, null },
            .src_constraints = .{
                .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } },
                .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } },
                .any,
            },
            .patterns = &.{
                .{ .src = .{ .to_mem, .to_mem, .none } },
            },
            .call_frame = .{ .alignment = .@"16" },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                .{ .type = .usize, .kind = .{ .extern_func = "__udivti3" } },
                .{ .type = .u128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._, .lea, .tmp2p, .memia(.src1, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
                .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .@"64bit", null, null, null },
            .src_constraints = .{
                .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } },
                .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } },
                .any,
            },
            .patterns = &.{
                .{ .src = .{ .to_mut_mem, .to_mut_mem, .none } },
            },
            .call_frame = .{ .alignment = .@"16" },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
                .{ .type = .usize, .kind = .{ .extern_func = "__divei4" } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._, .lea, .tmp1p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._, .lea, .tmp2p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._, .lea, .tmp3p, .memia(.src1, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._, .mov, .tmp4d, .sa(.src0, .add_bit_size), ._, ._ },
                .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        }, .{
            .required_features = .{ .@"64bit", null, null, null },
            .src_constraints = .{
                .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } },
                .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } },
                .any,
            },
            .patterns = &.{
                .{ .src = .{ .to_mut_mem, .to_mut_mem, .none } },
            },
            .call_frame = .{ .alignment = .@"16" },
            .extra_temps = .{
                .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } },
                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } },
                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } },
                .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } },
                .{ .type = .usize, .kind = .{ .extern_func = "__udivei4" } },
                .unused,
                .unused,
                .unused,
                .unused,
                .unused,
            },
            .dst_temps = .{ .mem, .unused },
            .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
            .each = .{ .once = &.{
                .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
                .{ .@"0:", ._, .lea, .tmp1p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._, .lea, .tmp2p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._, .lea, .tmp3p, .memia(.src1, .tmp0, .add_unaligned_size), ._, ._ },
                .{ ._, ._, .mov, .tmp4d, .sa(.src0, .add_bit_size), ._, ._ },
                .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
                .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
                .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
            } },
        } });
        lhs.*, rhs.* = ops;
        return res[0];
    }

    fn finish(
        temp: Temp,
        inst: Air.Inst.Index,
        op_refs: []const Air.Inst.Ref,
        op_temps: []const Temp,
        cg: *CodeGen,
    ) InnerError!void {
        const tomb_bits = cg.liveness.getTombBits(inst);
        for (0.., op_refs, op_temps) |op_index, op_ref, op_temp| {
            if (op_temp.index == temp.index) continue;
            if (op_temp.tracking(cg).short != .dead) try op_temp.die(cg);
            if (tomb_bits & @as(Air.Liveness.Bpi, 1) << @intCast(op_index) == 0) continue;
            if (cg.reused_operands.isSet(op_index)) continue;
            try cg.processDeath(op_ref.toIndexAllowNone() orelse continue, .{});
        }
        if (cg.liveness.isUnused(inst)) try temp.die(cg) else {
            switch (temp.unwrap(cg)) {
                .ref, .err_ret_trace => {
                    const temp_mcv = temp.tracking(cg).short;
                    const result = result: switch (temp_mcv) {
                        .none,
                        .unreach,
                        .dead,
                        .indirect_load_frame,
                        .elementwise_args,
                        .reserved_frame,
                        .air_ref,
                        => unreachable,
                        .undef, .immediate, .lea_frame => temp_mcv,
                        .eflags,
                        .register,
                        .register_pair,
                        .register_triple,
                        .register_quadruple,
                        .register_offset,
                        .register_overflow,
                        .register_mask,
                        .memory,
                        .indirect,
                        .load_frame,
                        .load_nav,
                        .lea_nav,
                        .load_uav,
                        .lea_uav,
                        .load_lazy_sym,
                        .lea_lazy_sym,
                        .load_extern_func,
                        .lea_extern_func,
                        => {
                            const result = try cg.allocRegOrMem(inst, true);
                            try cg.genCopy(cg.typeOfIndex(inst), result, temp_mcv, .{});
                            break :result result;
                        },
                    };
                    tracking_log.debug("{f} => {f} (birth)", .{ inst, result });
                    cg.inst_tracking.putAssumeCapacityNoClobber(inst, .init(result));
                },
                .temp => |temp_index| {
                    const temp_tracking = temp_index.tracking(cg);
                    tracking_log.debug("{f} => {f} (birth)", .{ inst, temp_tracking.short });
                    cg.inst_tracking.putAssumeCapacityNoClobber(inst, .init(temp_tracking.short));
                    assert(cg.reuseTemp(inst, temp_index.toIndex(), temp_tracking));
                },
            }
        }
        for (0.., op_refs, op_temps) |op_index, op_ref, op_temp| {
            if (op_temp.index != temp.index) continue;
            if (tomb_bits & @as(Air.Liveness.Bpi, 1) << @intCast(op_index) == 0) continue;
            if (cg.reused_operands.isSet(op_index)) continue;
            try cg.processDeath(op_ref.toIndexAllowNone() orelse continue, .{});
        }
    }

    fn die(temp: Temp, cg: *CodeGen) InnerError!void {
        switch (temp.unwrap(cg)) {
            .ref, .err_ret_trace => {},
            .temp => |temp_index| try temp_index.tracking(cg).die(cg, temp_index.toIndex(), .{}),
        }
    }

    const Index = enum(u5) {
        _,

        fn toIndex(index: Index) Air.Inst.Index {
            return .fromTargetIndex(@intFromEnum(index));
        }

        fn fromIndex(index: Air.Inst.Index) Index {
            return @enumFromInt(index.toTargetIndex());
        }

        fn tracking(index: Index, cg: *CodeGen) *InstTracking {
            return &cg.inst_tracking.values()[@intFromEnum(index)];
        }

        fn isValid(index: Index, cg: *CodeGen) bool {
            return @intFromEnum(index) < @intFromEnum(cg.next_temp_index) and
                index.tracking(cg).short != .dead;
        }

        fn typeOf(index: Index, cg: *CodeGen) Type {
            assert(index.isValid(cg));
            return cg.temp_type[@intFromEnum(index)];
        }

        const max = std.math.maxInt(@typeInfo(Index).@"enum".tag_type);
        const Set = std.StaticBitSet(max);
        const SafetySet = if (std.debug.runtime_safety) Set else struct {
            inline fn initEmpty() @This() {
                return .{};
            }

            inline fn isSet(_: @This(), index: usize) bool {
                assert(index < max);
                return true;
            }

            inline fn set(_: @This(), index: usize) void {
                assert(index < max);
            }

            inline fn eql(_: @This(), _: @This()) bool {
                return true;
            }
        };
    };
};

fn resetTemps(cg: *CodeGen, from_index: Temp.Index) InnerError!void {
    var any_valid = false;
    for (@intFromEnum(from_index)..@intFromEnum(cg.next_temp_index)) |temp_index| {
        const temp: Temp.Index = @enumFromInt(temp_index);
        if (temp.isValid(cg)) {
            any_valid = true;
            tracking_log.err("failed to kill {f}: {f}", .{
                temp.toIndex(),
                cg.temp_type[temp_index].fmt(cg.pt),
            });
        }
        cg.temp_type[temp_index] = undefined;
    }
    if (any_valid) return cg.fail("failed to kill all temps", .{});
    cg.next_temp_index = from_index;
}

fn reuseTemp(
    cg: *CodeGen,
    new_inst: Air.Inst.Index,
    old_inst: Air.Inst.Index,
    tracking: *InstTracking,
) bool {
    switch (tracking.short) {
        .register,
        .register_pair,
        .register_offset,
        .register_overflow,
        .register_mask,
        .indirect,
        => for (tracking.short.getRegs()) |tracked_reg| {
            if (RegisterManager.indexOfRegIntoTracked(tracked_reg)) |tracked_index| {
                cg.register_manager.registers[tracked_index] = new_inst;
            }
        },
        .load_frame => |frame_addr| if (frame_addr.index.isNamed()) return false,
        else => {},
    }
    switch (tracking.short) {
        .eflags, .register_overflow => cg.eflags_inst = new_inst,
        else => {},
    }
    tracking.reuse(cg, new_inst, old_inst);
    return true;
}

fn tempAlloc(cg: *CodeGen, ty: Type) InnerError!Temp {
    const temp_index = cg.next_temp_index;
    temp_index.tracking(cg).* = .init(
        try cg.allocRegOrMemAdvanced(ty, temp_index.toIndex(), true),
    );
    cg.temp_type[@intFromEnum(temp_index)] = ty;
    cg.next_temp_index = @enumFromInt(@intFromEnum(temp_index) + 1);
    return .{ .index = temp_index.toIndex() };
}

fn tempAllocReg(cg: *CodeGen, ty: Type, rs: RegisterManager.RegisterBitSet) InnerError!Temp {
    const temp_index = cg.next_temp_index;
    temp_index.tracking(cg).* = .init(
        .{ .register = try cg.register_manager.allocReg(temp_index.toIndex(), rs) },
    );
    cg.temp_type[@intFromEnum(temp_index)] = ty;
    cg.next_temp_index = @enumFromInt(@intFromEnum(temp_index) + 1);
    return .{ .index = temp_index.toIndex() };
}

fn tempAllocRegPair(cg: *CodeGen, ty: Type, rs: RegisterManager.RegisterBitSet) InnerError!Temp {
    const temp_index = cg.next_temp_index;
    temp_index.tracking(cg).* = .init(
        .{ .register_pair = try cg.register_manager.allocRegs(2, @splat(temp_index.toIndex()), rs) },
    );
    cg.temp_type[@intFromEnum(temp_index)] = ty;
    cg.next_temp_index = @enumFromInt(@intFromEnum(temp_index) + 1);
    return .{ .index = temp_index.toIndex() };
}

fn tempAllocMem(cg: *CodeGen, ty: Type) InnerError!Temp {
    const temp_index = cg.next_temp_index;
    temp_index.tracking(cg).* = .init(
        try cg.allocRegOrMemAdvanced(ty, temp_index.toIndex(), false),
    );
    cg.temp_type[@intFromEnum(temp_index)] = ty;
    cg.next_temp_index = @enumFromInt(@intFromEnum(temp_index) + 1);
    return .{ .index = temp_index.toIndex() };
}

fn tempInit(cg: *CodeGen, ty: Type, value: MCValue) InnerError!Temp {
    const temp_index = cg.next_temp_index;
    temp_index.tracking(cg).* = .init(value);
    cg.temp_type[@intFromEnum(temp_index)] = ty;
    try cg.getValue(value, temp_index.toIndex());
    cg.next_temp_index = @enumFromInt(@intFromEnum(temp_index) + 1);
    return .{ .index = temp_index.toIndex() };
}

fn tempFromValue(cg: *CodeGen, value: Value) InnerError!Temp {
    return cg.tempInit(value.typeOf(cg.pt.zcu), try cg.lowerValue(value));
}

fn tempMemFromValue(cg: *CodeGen, value: Value) InnerError!Temp {
    return cg.tempMemFromAlignedValue(.none, value);
}

fn tempMemFromAlignedValue(cg: *CodeGen, alignment: InternPool.Alignment, value: Value) InnerError!Temp {
    const ty = value.typeOf(cg.pt.zcu);
    return cg.tempInit(ty, .{ .load_uav = .{
        .val = value.toIntern(),
        .orig_ty = (try cg.pt.ptrType(.{
            .child = ty.toIntern(),
            .flags = .{
                .is_const = true,
                .alignment = alignment,
            },
        })).toIntern(),
    } });
}

fn tempFromOperand(cg: *CodeGen, op_ref: Air.Inst.Ref, op_dies: bool) InnerError!Temp {
    if (op_dies) {
        const temp_index = cg.next_temp_index;
        const temp: Temp = .{ .index = temp_index.toIndex() };
        const op_inst = op_ref.toIndex().?;
        const tracking = cg.getResolvedInstValue(op_inst);
        temp_index.tracking(cg).* = tracking.*;
        if (!cg.reuseTemp(temp.index, op_inst, tracking)) return .{ .index = op_ref.toIndex().? };
        cg.temp_type[@intFromEnum(temp_index)] = cg.typeOf(op_ref);
        cg.next_temp_index = @enumFromInt(@intFromEnum(temp_index) + 1);
        return temp;
    }

    if (op_ref.toIndex()) |op_inst| return .{ .index = op_inst };
    return cg.tempFromValue(.fromInterned(op_ref.toInterned().?));
}

fn tempsFromOperandsInner(
    cg: *CodeGen,
    inst: Air.Inst.Index,
    op_temps: []Temp,
    op_refs: []const Air.Inst.Ref,
) InnerError!void {
    for (op_temps, 0.., op_refs) |*op_temp, op_index, op_ref| op_temp.* = try cg.tempFromOperand(op_ref, for (op_refs[0..op_index]) |prev_op_ref| {
        if (op_ref == prev_op_ref) break false;
    } else cg.liveness.operandDies(inst, @intCast(op_index)));
}

inline fn tempsFromOperands(
    cg: *CodeGen,
    inst: Air.Inst.Index,
    op_refs: anytype,
) InnerError![op_refs.len]Temp {
    var op_temps: [op_refs.len]Temp = undefined;
    try cg.tempsFromOperandsInner(inst, &op_temps, &op_refs);
    return op_temps;
}

const Operand = union(enum) {
    none,
    reg: Register,
    mem: Memory,
    imm: Immediate,
    inst: Mir.Inst.Index,
};

const Select = struct {
    cg: *CodeGen,
    types: [@intFromEnum(Select.Operand.Ref.none)]Type,
    temps: [@intFromEnum(Select.Operand.Ref.none)]Temp,
    labels: [@intFromEnum(Label._)]struct {
        backward: ?Mir.Inst.Index,
        forward: [3]?Mir.Inst.Index,
    },
    top: u3,

    const Error = InnerError || error{SelectFailed};

    fn emitLabel(s: *Select, label_index: Label) void {
        assert(@intFromEnum(label_index) < @intFromEnum(Label._));
        const label = &s.labels[@intFromEnum(label_index)];
        for (&label.forward) |*reloc| {
            if (reloc.*) |r| s.cg.performReloc(r);
            reloc.* = null;
        }
        label.backward = @intCast(s.cg.mir_instructions.len);
    }

    fn emit(s: *Select, inst: Instruction) InnerError!void {
        const mir_tag: Mir.Inst.FixedTag = .{ inst[1], inst[2] };
        pseudo: {
            switch (inst[0]) {
                .@"0:", .@"1:", .@"2:", .@"3:", .@"4:" => |label| s.emitLabel(label),
                ._ => {},
                .pseudo => break :pseudo,
            }
            var mir_ops: [4]CodeGen.Operand = undefined;
            inline for (&mir_ops, 3..) |*mir_op, inst_index| mir_op.* = try inst[inst_index].lower(s);
            s.cg.asmOps(mir_tag, mir_ops) catch |err| switch (err) {
                error.InvalidInstruction => {
                    const fixes = @tagName(mir_tag[0]);
                    const fixes_blank = std.mem.indexOfScalar(u8, fixes, '_').?;
                    return s.cg.fail("invalid instruction: '{s}{s}{s} {s} {s} {s} {s}'", .{
                        fixes[0..fixes_blank],
                        @tagName(mir_tag[1]),
                        fixes[fixes_blank + 1 ..],
                        @tagName(mir_ops[0]),
                        @tagName(mir_ops[1]),
                        @tagName(mir_ops[2]),
                        @tagName(mir_ops[3]),
                    });
                },
                else => |e| return e,
            };
        }
        switch (mir_tag[0]) {
            .f_ => switch (mir_tag[1]) {
                .@"2xm1",
                .abs,
                .add,
                .chs,
                .clex,
                .com,
                .comi,
                .cos,
                .div,
                .divr,
                .free,
                .mul,
                .nop,
                .prem,
                .rndint,
                .scale,
                .sin,
                .sqrt,
                .st,
                .sub,
                .subr,
                .tst,
                .ucom,
                .ucomi,
                .wait,
                .xam,
                .xch,
                => {},
                .init, .save => s.top = 0,
                .ld, .ptan, .sincos, .xtract => s.top -%= 1,
                .patan, .yl2x => s.top +%= 1,
                .rstor => unreachable,
                else => unreachable,
            },
            .f_1 => switch (mir_tag[1]) {
                .ld => s.top -%= 1,
                .prem => {},
                else => unreachable,
            },
            .f_b, .f_be, .f_e, .f_nb, .f_nbe, .f_ne, .f_nu, .f_u => switch (mir_tag[1]) {
                .cmov => {},
                else => unreachable,
            },
            .f_cw, .f_env, .f_sw => switch (mir_tag[1]) {
                .ld, .st => {},
                else => unreachable,
            },
            .f_p1 => switch (mir_tag[1]) {
                .yl2x => s.top +%= 1,
                else => unreachable,
            },
            .f_cstp => switch (mir_tag[1]) {
                .de => s.top -%= 1,
                .in => s.top +%= 1,
                else => unreachable,
            },
            .f_l2e, .f_l2t, .f_lg2, .f_ln2, .f_pi, .f_z => switch (mir_tag[1]) {
                .ld => s.top -%= 1,
                else => unreachable,
            },
            .f_p => switch (mir_tag[1]) {
                .add, .com, .comi, .div, .divr, .mul, .st, .sub, .subr, .ucom, .ucomi => s.top +%= 1,
                else => {
                    const fixes = @tagName(mir_tag[0]);
                    const fixes_blank = std.mem.indexOfScalar(u8, fixes, '_').?;
                    std.debug.panic("{s}: {s}{s}{s}\n", .{
                        @src().fn_name,
                        fixes[0..fixes_blank],
                        @tagName(mir_tag[1]),
                        fixes[fixes_blank + 1 ..],
                    });
                },
            },
            .f_pp => switch (mir_tag[1]) {
                .com, .ucom => s.top +%= 2,
                else => unreachable,
            },
            .fb_ => switch (mir_tag[1]) {
                .ld => s.top -%= 1,
                else => unreachable,
            },
            .fb_p => switch (mir_tag[1]) {
                .st => s.top +%= 1,
                else => unreachable,
            },
            .fi_ => switch (mir_tag[1]) {
                .add, .com, .div, .divr, .mul, .st, .stt, .sub, .subr => {},
                .ld => s.top -%= 1,
                else => unreachable,
            },
            .fi_p => switch (mir_tag[1]) {
                .com, .st, .stt => s.top +%= 1,
                else => unreachable,
            },
            .fn_ => switch (mir_tag[1]) {
                .clex => {},
                .init, .save => s.top = 0,
                else => unreachable,
            },
            .fn_cw, .fn_env, .fn_sw => switch (mir_tag[1]) {
                .st => {},
                else => unreachable,
            },
            .fx_ => switch (mir_tag[1]) {
                .rstor => unreachable,
                .save => {},
                else => unreachable,
            },
            else => {},
        }
    }

    fn lowerReg(s: *const Select, reg: Register) Register {
        return if (reg.isClass(.x87)) @enumFromInt(@intFromEnum(Register.st0) + (@as(u3, @intCast(reg.enc())) -% s.top)) else reg;
    }

    const Case = struct {
        required_abi: enum { any, gnu, msvc } = .any,
        required_cc_abi: enum { any, sysv64, win64 } = .any,
        required_features: [4]?std.Target.x86.Feature = @splat(null),
        src_constraints: [@intFromEnum(Select.Operand.Ref.none) - @intFromEnum(Select.Operand.Ref.src0)]Constraint = @splat(.any),
        dst_constraints: [@intFromEnum(Select.Operand.Ref.src0) - @intFromEnum(Select.Operand.Ref.dst0)]Constraint = @splat(.any),
        patterns: []const Select.Pattern,
        call_frame: packed struct(u16) { size: u10 = 0, alignment: InternPool.Alignment } = .{ .size = 0, .alignment = .none },
        extra_temps: [@intFromEnum(Select.Operand.Ref.dst0) - @intFromEnum(Select.Operand.Ref.tmp0)]TempSpec = @splat(.unused),
        dst_temps: [@intFromEnum(Select.Operand.Ref.src0) - @intFromEnum(Select.Operand.Ref.dst0)]TempSpec.Kind = @splat(.unused),
        clobbers: packed struct {
            eflags: bool = false,
            caller_preserved: CallConv = .none,
        } = .{},
        each: union(enum) {
            once: []const Instruction,
        },

        const CallConv = enum(u2) { none, ccc, zigcc };
    };

    const Constraint = union(enum) {
        any,
        any_bool_vec,
        any_int,
        any_signed_int,
        any_unsigned_int,
        any_scalar_int,
        any_scalar_signed_int,
        any_scalar_unsigned_int,
        any_signed_int_or_full_vec,
        any_float,
        po2_any,
        bool,
        bool_vec: Memory.Size,
        exact_bool_vec: u16,
        ptr_any_bool_vec,
        ptr_bool_vec: Memory.Size,
        ptr_any_bool_vec_elem,
        ptr_bool_vec_elem: Memory.Size,
        remainder_bool_vec: OfIsSizes,
        exact_remainder_bool_vec: struct { of: Memory.Size, is: u16 },
        signed_int_vec: Memory.Size,
        signed_int_or_full_vec: Memory.Size,
        unsigned_int_vec: Memory.Size,
        size: Memory.Size,
        multiple_size: Memory.Size,
        int: Memory.Size,
        int_or_float: Memory.Size,
        scalar_int_is: Memory.Size,
        scalar_signed_int_is: Memory.Size,
        scalar_unsigned_int_is: Memory.Size,
        scalar: OfIsSizes,
        scalar_int: OfIsSizes,
        scalar_signed_int: OfIsSizes,
        scalar_unsigned_int: OfIsSizes,
        exclusive_scalar_int: OfIsSizes,
        exclusive_scalar_signed_int: OfIsSizes,
        exclusive_scalar_unsigned_int: OfIsSizes,
        exact_scalar_int: OfIsSizes,
        exact_scalar_signed_int: OfIsSizes,
        exact_scalar_unsigned_int: OfIsSizes,
        scalar_signed_or_exclusive_int: OfIsSizes,
        scalar_exact_int: struct { of: Memory.Size, is: u16 },
        scalar_exact_signed_int: struct { of: Memory.Size, is: u16 },
        scalar_exact_unsigned_int: struct { of: Memory.Size, is: u16 },
        multiple_scalar: OfIsSizes,
        multiple_scalar_int: OfIsSizes,
        unaligned_multiple_scalar_int: OfIsSizes,
        unaligned_multiple_scalar_signed_int: OfIsSizes,
        unaligned_multiple_scalar_unsigned_int: OfIsSizes,
        multiple_scalar_signed_int: OfIsSizes,
        multiple_scalar_unsigned_int: OfIsSizes,
        multiple_scalar_signed_or_exclusive_int: OfIsSizes,
        multiple_scalar_exact_int: struct { of: Memory.Size, is: u16 },
        multiple_scalar_exact_signed_int: struct { of: Memory.Size, is: u16 },
        multiple_scalar_exact_unsigned_int: struct { of: Memory.Size, is: u16 },
        scalar_remainder_int: OfIsSizes,
        scalar_remainder_signed_int: OfIsSizes,
        scalar_remainder_unsigned_int: OfIsSizes,
        scalar_exact_remainder_int: OfIsSizes,
        scalar_exact_remainder_signed_int: OfIsSizes,
        scalar_exact_remainder_unsigned_int: OfIsSizes,
        float: Memory.Size,
        scalar_any_float: Memory.Size,
        scalar_float: OfIsSizes,
        exclusive_scalar_float: OfIsSizes,
        exact_scalar_float: OfIsSizes,
        multiple_scalar_any_float: Memory.Size,
        multiple_scalar_float: OfIsSizes,
        unaligned_multiple_scalar_float: OfIsSizes,
        exact_int: u16,
        exact_signed_int: u16,
        exact_unsigned_int: u16,
        signed_or_exact_int: Memory.Size,
        unsigned_or_exact_int: Memory.Size,
        signed_or_exclusive_int: Memory.Size,
        po2_int: Memory.Size,
        signed_po2_int: Memory.Size,
        unsigned_po2_or_exact_int: Memory.Size,
        remainder_int: OfIsSizes,
        remainder_signed_int: OfIsSizes,
        remainder_unsigned_int: OfIsSizes,
        exact_remainder_int: struct { of: Memory.Size, is: u16 },
        exact_remainder_signed_int: struct { of: Memory.Size, is: u16 },
        exact_remainder_unsigned_int: struct { of: Memory.Size, is: u16 },
        signed_or_exact_remainder_int: OfIsSizes,
        unsigned_or_exact_remainder_int: OfIsSizes,
        signed_int: Memory.Size,
        unsigned_int: Memory.Size,
        elem_size_is: u8,
        po2_elem_size,
        elem_int: Memory.Size,

        const OfIsSizes = struct { of: Memory.Size, is: Memory.Size };

        fn accepts(constraint: Constraint, ty: Type, cg: *CodeGen) bool {
            const zcu = cg.pt.zcu;
            return switch (constraint) {
                .any => true,
                .any_bool_vec => ty.isVector(zcu) and ty.childType(zcu).toIntern() == .bool_type,
                .any_int => cg.intInfo(ty) != null,
                .any_signed_int => if (cg.intInfo(ty)) |int_info| int_info.signedness == .signed else false,
                .any_unsigned_int => if (cg.intInfo(ty)) |int_info| int_info.signedness == .unsigned else false,
                .any_scalar_int => cg.intInfo(ty.scalarType(zcu)) != null,
                .any_scalar_signed_int => if (cg.intInfo(ty.scalarType(zcu))) |int_info| int_info.signedness == .signed else false,
                .any_scalar_unsigned_int => if (cg.intInfo(ty.scalarType(zcu))) |int_info| int_info.signedness == .unsigned else false,
                .any_signed_int_or_full_vec => ty.isVector(zcu) and
                    if (cg.intInfo(ty.childType(zcu))) |int_info| switch (int_info.signedness) {
                        .signed => true,
                        .unsigned => (int_info.bits >= 8 and std.math.isPowerOfTwo(int_info.bits)) or int_info.bits % 128 == 0,
                    } else false,
                .any_float => ty.isRuntimeFloat(),
                .po2_any => std.math.isPowerOfTwo(ty.abiSize(zcu)),
                .bool => ty.toIntern() == .bool_type,
                .bool_vec => |size| ty.isVector(zcu) and ty.scalarType(zcu).toIntern() == .bool_type and
                    size.bitSize(cg.target) >= ty.vectorLen(zcu),
                .exact_bool_vec => |size| ty.isVector(zcu) and ty.scalarType(zcu).toIntern() == .bool_type and
                    size == ty.vectorLen(zcu),
                .ptr_any_bool_vec => switch (zcu.intern_pool.indexToKey(ty.childType(zcu).toIntern())) {
                    .vector_type => |vector_type| vector_type.child == .bool_type,
                    else => false,
                },
                .ptr_bool_vec => |size| switch (zcu.intern_pool.indexToKey(ty.childType(zcu).toIntern())) {
                    .vector_type => |vector_type| vector_type.child == .bool_type and size.bitSize(cg.target) >= vector_type.len,
                    else => false,
                },
                .ptr_any_bool_vec_elem => {
                    const ptr_info = ty.ptrInfo(zcu);
                    return switch (ptr_info.flags.vector_index) {
                        .none => false,
                        else => ptr_info.child == .bool_type,
                    };
                },
                .ptr_bool_vec_elem => |size| {
                    const ptr_info = ty.ptrInfo(zcu);
                    return switch (ptr_info.flags.vector_index) {
                        .none => false,
                        else => ptr_info.child == .bool_type and size.bitSize(cg.target) >= ptr_info.packed_offset.host_size,
                    };
                },
                .remainder_bool_vec => |of_is| ty.isVector(zcu) and ty.scalarType(zcu).toIntern() == .bool_type and
                    of_is.is.bitSize(cg.target) >= (ty.vectorLen(zcu) - 1) % of_is.of.bitSize(cg.target) + 1,
                .exact_remainder_bool_vec => |of_is| ty.isVector(zcu) and ty.scalarType(zcu).toIntern() == .bool_type and
                    of_is.is == (ty.vectorLen(zcu) - 1) % of_is.of.bitSize(cg.target) + 1,
                .signed_int_vec => |size| ty.isVector(zcu) and @divExact(size.bitSize(cg.target), 8) >= ty.abiSize(zcu) and
                    if (cg.intInfo(ty.childType(zcu))) |int_info| int_info.signedness == .signed else false,
                .signed_int_or_full_vec => |size| ty.isVector(zcu) and @divExact(size.bitSize(cg.target), 8) >= ty.abiSize(zcu) and
                    if (cg.intInfo(ty.childType(zcu))) |int_info| switch (int_info.signedness) {
                        .signed => true,
                        .unsigned => (int_info.bits >= 8 and std.math.isPowerOfTwo(int_info.bits)) or int_info.bits % 128 == 0,
                    } else false,
                .unsigned_int_vec => |size| ty.isVector(zcu) and @divExact(size.bitSize(cg.target), 8) >= ty.abiSize(zcu) and
                    if (cg.intInfo(ty.childType(zcu))) |int_info| int_info.signedness == .unsigned else false,
                .size => |size| @divExact(size.bitSize(cg.target), 8) >= ty.abiSize(zcu),
                .multiple_size => |size| ty.abiSize(zcu) % @divExact(size.bitSize(cg.target), 8) == 0,
                .int => |size| if (cg.intInfo(ty)) |int_info| size.bitSize(cg.target) >= int_info.bits else false,
                .int_or_float => |size| if (cg.intInfo(ty)) |int_info|
                    size.bitSize(cg.target) >= int_info.bits
                else if (cg.floatBits(ty)) |float_bits|
                    size.bitSize(cg.target) == float_bits
                else
                    false,
                .scalar_int_is => |size| if (cg.intInfo(ty.scalarType(zcu))) |int_info|
                    size.bitSize(cg.target) >= int_info.bits
                else
                    false,
                .scalar_signed_int_is => |size| if (cg.intInfo(ty.scalarType(zcu))) |int_info| switch (int_info.signedness) {
                    .signed => size.bitSize(cg.target) >= int_info.bits,
                    .unsigned => false,
                } else false,
                .scalar_unsigned_int_is => |size| if (cg.intInfo(ty.scalarType(zcu))) |int_info| switch (int_info.signedness) {
                    .signed => false,
                    .unsigned => size.bitSize(cg.target) >= int_info.bits,
                } else false,
                .scalar => |of_is| @divExact(of_is.of.bitSize(cg.target), 8) >= cg.unalignedSize(ty) and
                    if (cg.intInfo(ty.scalarType(zcu))) |int_info|
                        of_is.is.bitSize(cg.target) >= int_info.bits
                    else if (cg.floatBits(ty.scalarType(zcu))) |float_bits|
                        of_is.is.bitSize(cg.target) == float_bits
                    else
                        false,
                .scalar_int => |of_is| @divExact(of_is.of.bitSize(cg.target), 8) >= cg.unalignedSize(ty) and
                    if (cg.intInfo(ty.scalarType(zcu))) |int_info| of_is.is.bitSize(cg.target) >= int_info.bits else false,
                .scalar_signed_int => |of_is| @divExact(of_is.of.bitSize(cg.target), 8) >= cg.unalignedSize(ty) and
                    if (cg.intInfo(ty.scalarType(zcu))) |int_info| int_info.signedness == .signed and
                        of_is.is.bitSize(cg.target) >= int_info.bits else false,
                .scalar_unsigned_int => |of_is| @divExact(of_is.of.bitSize(cg.target), 8) >= cg.unalignedSize(ty) and
                    if (cg.intInfo(ty.scalarType(zcu))) |int_info| int_info.signedness == .unsigned and
                        of_is.is.bitSize(cg.target) >= int_info.bits else false,
                .exclusive_scalar_int => |of_is| @divExact(of_is.of.bitSize(cg.target), 8) > cg.unalignedSize(ty) and
                    if (cg.intInfo(ty.scalarType(zcu))) |int_info| of_is.is.bitSize(cg.target) >= int_info.bits else false,
                .exclusive_scalar_signed_int => |of_is| @divExact(of_is.of.bitSize(cg.target), 8) > cg.unalignedSize(ty) and
                    if (cg.intInfo(ty.scalarType(zcu))) |int_info| int_info.signedness == .signed and
                        of_is.is.bitSize(cg.target) >= int_info.bits else false,
                .exclusive_scalar_unsigned_int => |of_is| @divExact(of_is.of.bitSize(cg.target), 8) > cg.unalignedSize(ty) and
                    if (cg.intInfo(ty.scalarType(zcu))) |int_info| int_info.signedness == .unsigned and
                        of_is.is.bitSize(cg.target) >= int_info.bits else false,
                .exact_scalar_int => |of_is| @divExact(of_is.of.bitSize(cg.target), 8) == cg.unalignedSize(ty) and
                    if (cg.intInfo(ty.scalarType(zcu))) |int_info| of_is.is.bitSize(cg.target) >= int_info.bits else false,
                .exact_scalar_signed_int => |of_is| @divExact(of_is.of.bitSize(cg.target), 8) == cg.unalignedSize(ty) and
                    if (cg.intInfo(ty.scalarType(zcu))) |int_info| int_info.signedness == .signed and
                        of_is.is.bitSize(cg.target) >= int_info.bits else false,
                .exact_scalar_unsigned_int => |of_is| @divExact(of_is.of.bitSize(cg.target), 8) == cg.unalignedSize(ty) and
                    if (cg.intInfo(ty.scalarType(zcu))) |int_info| int_info.signedness == .unsigned and
                        of_is.is.bitSize(cg.target) >= int_info.bits else false,
                .scalar_signed_or_exclusive_int => |of_is| @divExact(of_is.of.bitSize(cg.target), 8) >= cg.unalignedSize(ty) and
                    if (cg.intInfo(ty)) |int_info| switch (int_info.signedness) {
                        .signed => of_is.is.bitSize(cg.target) >= int_info.bits,
                        .unsigned => of_is.is.bitSize(cg.target) > int_info.bits,
                    } else false,
                .scalar_exact_int => |of_is| @divExact(of_is.of.bitSize(cg.target), 8) >= cg.unalignedSize(ty) and
                    if (cg.intInfo(ty.scalarType(zcu))) |int_info| of_is.is == int_info.bits else false,
                .scalar_exact_signed_int => |of_is| @divExact(of_is.of.bitSize(cg.target), 8) >= cg.unalignedSize(ty) and
                    if (cg.intInfo(ty.scalarType(zcu))) |int_info| int_info.signedness == .signed and
                        of_is.is == int_info.bits else false,
                .scalar_exact_unsigned_int => |of_is| @divExact(of_is.of.bitSize(cg.target), 8) >= cg.unalignedSize(ty) and
                    if (cg.intInfo(ty.scalarType(zcu))) |int_info| int_info.signedness == .unsigned and
                        of_is.is == int_info.bits else false,
                .multiple_scalar => |of_is| ty.abiSize(zcu) % @divExact(of_is.of.bitSize(cg.target), 8) == 0 and
                    if (cg.intInfo(ty.scalarType(zcu))) |int_info|
                        of_is.is.bitSize(cg.target) >= int_info.bits
                    else if (cg.floatBits(ty.scalarType(zcu))) |float_bits|
                        of_is.is.bitSize(cg.target) == float_bits
                    else
                        false,
                .multiple_scalar_int => |of_is| ty.abiSize(zcu) % @divExact(of_is.of.bitSize(cg.target), 8) == 0 and
                    if (cg.intInfo(ty.scalarType(zcu))) |int_info| of_is.is.bitSize(cg.target) >= int_info.bits else false,
                .unaligned_multiple_scalar_int => |of_is| cg.unalignedSize(ty) % @divExact(of_is.of.bitSize(cg.target), 8) == 0 and
                    if (cg.intInfo(ty.scalarType(zcu))) |int_info| of_is.is.bitSize(cg.target) >= int_info.bits else false,
                .unaligned_multiple_scalar_signed_int => |of_is| cg.unalignedSize(ty) % @divExact(of_is.of.bitSize(cg.target), 8) == 0 and
                    if (cg.intInfo(ty.scalarType(zcu))) |int_info| int_info.signedness == .signed and
                        of_is.is.bitSize(cg.target) >= int_info.bits else false,
                .unaligned_multiple_scalar_unsigned_int => |of_is| cg.unalignedSize(ty) % @divExact(of_is.of.bitSize(cg.target), 8) == 0 and
                    if (cg.intInfo(ty.scalarType(zcu))) |int_info| int_info.signedness == .unsigned and
                        of_is.is.bitSize(cg.target) >= int_info.bits else false,
                .multiple_scalar_signed_int => |of_is| ty.abiSize(zcu) % @divExact(of_is.of.bitSize(cg.target), 8) == 0 and
                    if (cg.intInfo(ty.scalarType(zcu))) |int_info| int_info.signedness == .signed and
                        of_is.is.bitSize(cg.target) >= int_info.bits else false,
                .multiple_scalar_unsigned_int => |of_is| ty.abiSize(zcu) % @divExact(of_is.of.bitSize(cg.target), 8) == 0 and
                    if (cg.intInfo(ty.scalarType(zcu))) |int_info| int_info.signedness == .unsigned and
                        of_is.is.bitSize(cg.target) >= int_info.bits else false,
                .multiple_scalar_signed_or_exclusive_int => |of_is| ty.abiSize(zcu) % @divExact(of_is.of.bitSize(cg.target), 8) == 0 and
                    if (cg.intInfo(ty.scalarType(zcu))) |int_info| switch (int_info.signedness) {
                        .signed => of_is.is.bitSize(cg.target) >= int_info.bits,
                        .unsigned => of_is.is.bitSize(cg.target) > int_info.bits,
                    } else false,
                .multiple_scalar_exact_int => |of_is| ty.abiSize(zcu) % @divExact(of_is.of.bitSize(cg.target), 8) == 0 and
                    if (cg.intInfo(ty.scalarType(zcu))) |int_info| of_is.is == int_info.bits else false,
                .multiple_scalar_exact_signed_int => |of_is| ty.abiSize(zcu) % @divExact(of_is.of.bitSize(cg.target), 8) == 0 and
                    if (cg.intInfo(ty.scalarType(zcu))) |int_info| int_info.signedness == .signed and
                        of_is.is == int_info.bits else false,
                .multiple_scalar_exact_unsigned_int => |of_is| ty.abiSize(zcu) % @divExact(of_is.of.bitSize(cg.target), 8) == 0 and
                    if (cg.intInfo(ty.scalarType(zcu))) |int_info| int_info.signedness == .unsigned and
                        of_is.is == int_info.bits else false,
                .scalar_remainder_int => |of_is| if (cg.intInfo(ty.scalarType(zcu))) |int_info|
                    of_is.is.bitSize(cg.target) >= (int_info.bits - 1) % of_is.of.bitSize(cg.target) + 1
                else
                    false,
                .scalar_remainder_signed_int => |of_is| if (cg.intInfo(ty.scalarType(zcu))) |int_info| int_info.signedness == .signed and
                    of_is.is.bitSize(cg.target) >= (int_info.bits - 1) % of_is.of.bitSize(cg.target) + 1 else false,
                .scalar_remainder_unsigned_int => |of_is| if (cg.intInfo(ty.scalarType(zcu))) |int_info| int_info.signedness == .unsigned and
                    of_is.is.bitSize(cg.target) >= (int_info.bits - 1) % of_is.of.bitSize(cg.target) + 1 else false,
                .scalar_exact_remainder_int => |of_is| if (cg.intInfo(ty.scalarType(zcu))) |int_info|
                    of_is.is.bitSize(cg.target) == (int_info.bits - 1) % of_is.of.bitSize(cg.target) + 1
                else
                    false,
                .scalar_exact_remainder_signed_int => |of_is| if (cg.intInfo(ty.scalarType(zcu))) |int_info| int_info.signedness == .signed and
                    of_is.is.bitSize(cg.target) == (int_info.bits - 1) % of_is.of.bitSize(cg.target) + 1 else false,
                .scalar_exact_remainder_unsigned_int => |of_is| if (cg.intInfo(ty.scalarType(zcu))) |int_info| int_info.signedness == .unsigned and
                    of_is.is.bitSize(cg.target) == (int_info.bits - 1) % of_is.of.bitSize(cg.target) + 1 else false,
                .float => |size| if (cg.floatBits(ty)) |float_bits| size.bitSize(cg.target) == float_bits else false,
                .scalar_any_float => |size| @divExact(size.bitSize(cg.target), 8) >= ty.abiSize(zcu) and
                    cg.floatBits(ty.scalarType(zcu)) != null,
                .scalar_float => |of_is| @divExact(of_is.of.bitSize(cg.target), 8) >= cg.unalignedSize(ty) and
                    if (cg.floatBits(ty.scalarType(zcu))) |float_bits| of_is.is.bitSize(cg.target) == float_bits else false,
                .exclusive_scalar_float => |of_is| @divExact(of_is.of.bitSize(cg.target), 8) > cg.unalignedSize(ty) and
                    if (cg.floatBits(ty.scalarType(zcu))) |float_bits| of_is.is.bitSize(cg.target) == float_bits else false,
                .exact_scalar_float => |of_is| @divExact(of_is.of.bitSize(cg.target), 8) == cg.unalignedSize(ty) and
                    if (cg.floatBits(ty.scalarType(zcu))) |float_bits| of_is.is.bitSize(cg.target) == float_bits else false,
                .multiple_scalar_any_float => |size| ty.abiSize(zcu) % @divExact(size.bitSize(cg.target), 8) == 0 and
                    cg.floatBits(ty.scalarType(zcu)) != null,
                .multiple_scalar_float => |of_is| ty.abiSize(zcu) % @divExact(of_is.of.bitSize(cg.target), 8) == 0 and
                    if (cg.floatBits(ty.scalarType(zcu))) |float_bits| of_is.is.bitSize(cg.target) == float_bits else false,
                .unaligned_multiple_scalar_float => |of_is| cg.unalignedSize(ty) % @divExact(of_is.of.bitSize(cg.target), 8) == 0 and
                    if (cg.floatBits(ty.scalarType(zcu))) |float_bits| of_is.is.bitSize(cg.target) == float_bits else false,
                .exact_int => |bit_size| if (cg.intInfo(ty)) |int_info| bit_size == int_info.bits else false,
                .exact_signed_int => |bit_size| if (cg.intInfo(ty)) |int_info| switch (int_info.signedness) {
                    .signed => bit_size == int_info.bits,
                    .unsigned => false,
                } else false,
                .exact_unsigned_int => |bit_size| if (cg.intInfo(ty)) |int_info| switch (int_info.signedness) {
                    .signed => false,
                    .unsigned => bit_size == int_info.bits,
                } else false,
                .signed_or_exact_int => |size| if (cg.intInfo(ty)) |int_info| switch (int_info.signedness) {
                    .signed => size.bitSize(cg.target) >= int_info.bits,
                    .unsigned => size.bitSize(cg.target) == int_info.bits,
                } else false,
                .unsigned_or_exact_int => |size| if (cg.intInfo(ty)) |int_info| switch (int_info.signedness) {
                    .signed => size.bitSize(cg.target) == int_info.bits,
                    .unsigned => size.bitSize(cg.target) >= int_info.bits,
                } else false,
                .signed_or_exclusive_int => |size| if (cg.intInfo(ty)) |int_info| switch (int_info.signedness) {
                    .signed => size.bitSize(cg.target) >= int_info.bits,
                    .unsigned => size.bitSize(cg.target) > int_info.bits,
                } else false,
                .po2_int => |size| if (cg.intInfo(ty)) |int_info|
                    std.math.isPowerOfTwo(int_info.bits) and size.bitSize(cg.target) >= int_info.bits
                else
                    false,
                .signed_po2_int => |size| if (cg.intInfo(ty)) |int_info| switch (int_info.signedness) {
                    .signed => std.math.isPowerOfTwo(int_info.bits) and size.bitSize(cg.target) >= int_info.bits,
                    .unsigned => false,
                } else false,
                .unsigned_po2_or_exact_int => |size| if (cg.intInfo(ty)) |int_info| switch (int_info.signedness) {
                    .signed => size.bitSize(cg.target) == int_info.bits,
                    .unsigned => std.math.isPowerOfTwo(int_info.bits) and size.bitSize(cg.target) >= int_info.bits,
                } else false,
                .remainder_int => |of_is| if (cg.intInfo(ty)) |int_info|
                    of_is.is.bitSize(cg.target) >= (int_info.bits - 1) % of_is.of.bitSize(cg.target) + 1
                else
                    false,
                .remainder_signed_int => |of_is| if (cg.intInfo(ty)) |int_info| int_info.signedness == .signed and
                    of_is.is.bitSize(cg.target) >= (int_info.bits - 1) % of_is.of.bitSize(cg.target) + 1 else false,
                .remainder_unsigned_int => |of_is| if (cg.intInfo(ty)) |int_info| int_info.signedness == .unsigned and
                    of_is.is.bitSize(cg.target) >= (int_info.bits - 1) % of_is.of.bitSize(cg.target) + 1 else false,
                .exact_remainder_int => |of_is| if (cg.intInfo(ty)) |int_info|
                    of_is.is == (int_info.bits - 1) % of_is.of.bitSize(cg.target) + 1
                else
                    false,
                .exact_remainder_signed_int => |of_is| if (cg.intInfo(ty)) |int_info| int_info.signedness == .signed and
                    of_is.is == (int_info.bits - 1) % of_is.of.bitSize(cg.target) + 1 else false,
                .exact_remainder_unsigned_int => |of_is| if (cg.intInfo(ty)) |int_info| int_info.signedness == .unsigned and
                    of_is.is == (int_info.bits - 1) % of_is.of.bitSize(cg.target) + 1 else false,
                .signed_or_exact_remainder_int => |of_is| if (cg.intInfo(ty)) |int_info| switch (int_info.signedness) {
                    .signed => of_is.is.bitSize(cg.target) >= (int_info.bits - 1) % of_is.of.bitSize(cg.target) + 1,
                    .unsigned => of_is.is.bitSize(cg.target) == (int_info.bits - 1) % of_is.of.bitSize(cg.target) + 1,
                } else false,
                .unsigned_or_exact_remainder_int => |of_is| if (cg.intInfo(ty)) |int_info| switch (int_info.signedness) {
                    .signed => of_is.is.bitSize(cg.target) == (int_info.bits - 1) % of_is.of.bitSize(cg.target) + 1,
                    .unsigned => of_is.is.bitSize(cg.target) >= (int_info.bits - 1) % of_is.of.bitSize(cg.target) + 1,
                } else false,
                .signed_int => |size| if (cg.intInfo(ty)) |int_info| switch (int_info.signedness) {
                    .signed => size.bitSize(cg.target) >= int_info.bits,
                    .unsigned => false,
                } else false,
                .unsigned_int => |size| if (cg.intInfo(ty)) |int_info| switch (int_info.signedness) {
                    .signed => false,
                    .unsigned => size.bitSize(cg.target) >= int_info.bits,
                } else false,
                .elem_size_is => |size| size == ty.elemType2(zcu).abiSize(zcu),
                .po2_elem_size => std.math.isPowerOfTwo(ty.elemType2(zcu).abiSize(zcu)),
                .elem_int => |size| if (cg.intInfo(ty.elemType2(zcu))) |elem_int_info|
                    size.bitSize(cg.target) >= elem_int_info.bits
                else
                    false,
            };
        }
    };

    const Pattern = struct {
        src: [@intFromEnum(Select.Operand.Ref.none) - @intFromEnum(Select.Operand.Ref.src0)]Src,
        commute: struct { u8, u8 } = .{ 0, 0 },

        const Src = union(enum) {
            none,
            any,
            imm: i16,
            imm8,
            imm16,
            imm32,
            simm32,
            to_reg: Register,
            to_reg_pair: [2]Register,
            to_param_gpr: TempSpec.Kind.CallConvRegSpec,
            to_param_gpr_pair: TempSpec.Kind.CallConvRegSpec,
            to_param_sse: TempSpec.Kind.CallConvRegSpec,
            to_ret_gpr: TempSpec.Kind.CallConvRegSpec,
            to_ret_gpr_pair: TempSpec.Kind.CallConvRegSpec,
            mem,
            to_mem,
            mut_mem,
            to_mut_mem,
            gpr,
            immut_gpr,
            to_gpr,
            mut_gpr,
            to_mut_gpr,
            to_gphi,
            to_mut_gphi,
            x87,
            to_x87,
            mut_x87,
            to_mut_x87,
            mmx,
            to_mmx,
            mut_mmx,
            to_mut_mmx,
            sse,
            to_sse,
            mut_sse,
            to_mut_sse,
            reg_mask: RegMaskSpec,
            all_reg_mask: RegMaskSpec,

            const RegMaskSpec = struct {
                size: Memory.Size,
                is: enum {
                    any,
                    uninverted,
                    inverted,

                    fn matches(is: @This(), inverted: bool) bool {
                        return switch (is) {
                            .any => true,
                            .uninverted => !inverted,
                            .inverted => inverted,
                        };
                    }
                } = .any,
            };

            fn matches(src: Src, temp: Temp, cg: *CodeGen) bool {
                return switch (src) {
                    .none => temp.tracking(cg).short == .none,
                    .any => true,
                    .imm => |specific_imm| switch (temp.tracking(cg).short) {
                        .immediate => |imm| @as(i64, @bitCast(imm)) == specific_imm,
                        else => false,
                    },
                    .imm8 => switch (temp.tracking(cg).short) {
                        .immediate => |imm| std.math.cast(u8, imm) != null or
                            std.math.cast(i8, @as(i64, @bitCast(imm))) != null,
                        else => false,
                    },
                    .imm16 => switch (temp.tracking(cg).short) {
                        .immediate => |imm| std.math.cast(u16, imm) != null or
                            std.math.cast(i16, @as(i64, @bitCast(imm))) != null,
                        else => false,
                    },
                    .imm32 => switch (temp.tracking(cg).short) {
                        .immediate => |imm| std.math.cast(u32, imm) != null or
                            std.math.cast(i32, @as(i64, @bitCast(imm))) != null,
                        else => false,
                    },
                    .simm32 => switch (temp.tracking(cg).short) {
                        .immediate => |imm| std.math.cast(i32, @as(i64, @bitCast(imm))) != null,
                        else => false,
                    },
                    .mem => temp.tracking(cg).short.isMemory(),
                    .to_mem, .to_mut_mem => true,
                    .mut_mem => temp.isMut(cg) and temp.tracking(cg).short.isMemory(),
                    .to_reg, .to_reg_pair, .to_param_gpr, .to_param_gpr_pair, .to_param_sse, .to_ret_gpr, .to_ret_gpr_pair => true,
                    .gpr => temp.typeOf(cg).abiSize(cg.pt.zcu) <= 8 and switch (temp.tracking(cg).short) {
                        .register => |reg| reg.isClass(.general_purpose),
                        .register_offset => |reg_off| reg_off.reg.isClass(.general_purpose) and reg_off.off == 0,
                        else => false,
                    },
                    .immut_gpr => !temp.isMut(cg) and temp.typeOf(cg).abiSize(cg.pt.zcu) <= 8 and switch (temp.tracking(cg).short) {
                        .register => |reg| reg.isClass(.general_purpose),
                        .register_offset => |reg_off| reg_off.reg.isClass(.general_purpose) and reg_off.off == 0,
                        else => false,
                    },
                    .mut_gpr => temp.isMut(cg) and temp.typeOf(cg).abiSize(cg.pt.zcu) <= 8 and switch (temp.tracking(cg).short) {
                        .register => |reg| reg.isClass(.general_purpose),
                        .register_offset => |reg_off| reg_off.reg.isClass(.general_purpose) and reg_off.off == 0,
                        else => false,
                    },
                    .to_gpr, .to_mut_gpr, .to_gphi, .to_mut_gphi => temp.typeOf(cg).abiSize(cg.pt.zcu) <= 8,
                    .x87 => switch (temp.tracking(cg).short) {
                        .register => |reg| reg.isClass(.x87),
                        .register_offset => |reg_off| reg_off.reg.isClass(.x87) and reg_off.off == 0,
                        else => false,
                    },
                    .mut_x87 => temp.isMut(cg) and switch (temp.tracking(cg).short) {
                        .register => |reg| reg.isClass(.x87),
                        .register_offset => |reg_off| reg_off.reg.isClass(.x87) and reg_off.off == 0,
                        else => false,
                    },
                    .to_x87, .to_mut_x87 => true,
                    .mmx => switch (temp.tracking(cg).short) {
                        .register => |reg| reg.isClass(.mmx),
                        .register_offset => |reg_off| reg_off.reg.isClass(.mmx) and reg_off.off == 0,
                        else => false,
                    },
                    .mut_mmx => temp.isMut(cg) and switch (temp.tracking(cg).short) {
                        .register => |reg| reg.isClass(.mmx),
                        .register_offset => |reg_off| reg_off.reg.isClass(.mmx) and reg_off.off == 0,
                        else => false,
                    },
                    .to_mmx, .to_mut_mmx => true,
                    .sse => switch (temp.tracking(cg).short) {
                        .register => |reg| reg.isClass(.sse),
                        .register_offset => |reg_off| reg_off.reg.isClass(.sse) and reg_off.off == 0,
                        else => false,
                    },
                    .mut_sse => temp.isMut(cg) and switch (temp.tracking(cg).short) {
                        .register => |reg| reg.isClass(.sse),
                        .register_offset => |reg_off| reg_off.reg.isClass(.sse) and reg_off.off == 0,
                        else => false,
                    },
                    .to_sse, .to_mut_sse => true,
                    .reg_mask => |mask_spec| switch (temp.tracking(cg).short) {
                        .register_mask => |reg_mask| mask_spec.size.bitSize(cg.target) >=
                            reg_mask.info.scalar.bitSize(cg.target) * temp.typeOf(cg).vectorLen(cg.pt.zcu) and
                            mask_spec.is.matches(reg_mask.info.inverted),
                        else => false,
                    },
                    .all_reg_mask => |mask_spec| switch (temp.tracking(cg).short) {
                        .register_mask => |reg_mask| mask_spec.size.bitSize(cg.target) ==
                            reg_mask.info.scalar.bitSize(cg.target) * temp.typeOf(cg).vectorLen(cg.pt.zcu) and
                            reg_mask.info.kind == .all and mask_spec.is.matches(reg_mask.info.inverted),
                        else => false,
                    },
                };
            }

            fn convert(src: Src, temp: *Temp, cg: *CodeGen) InnerError!bool {
                return switch (src) {
                    .none, .any, .imm, .imm8, .imm16, .imm32, .simm32, .reg_mask, .all_reg_mask => false,
                    .mem, .to_mem => try temp.toBase(false, cg),
                    .mut_mem, .to_mut_mem => try temp.toBase(true, cg),
                    .to_reg => |reg| try temp.toReg(reg, cg),
                    .to_reg_pair => |regs| try temp.toRegPair(regs, cg),
                    .to_param_gpr => |param_spec| try temp.toReg(abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.index(cg)], cg),
                    .to_param_gpr_pair => |param_spec| try temp.toRegPair(abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.index(cg)..][0..2].*, cg),
                    .to_param_sse => |param_spec| try temp.toReg(abi.getCAbiSseParamRegs(param_spec.tag(cg), cg.target)[param_spec.index(cg)], cg),
                    .to_ret_gpr => |ret_spec| try temp.toReg(abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index(cg)], cg),
                    .to_ret_gpr_pair => |ret_spec| try temp.toRegPair(abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index(cg)..][0..2].*, cg),
                    .gpr, .immut_gpr, .to_gpr => try temp.toRegClass(false, .general_purpose, cg),
                    .mut_gpr, .to_mut_gpr => try temp.toRegClass(true, .general_purpose, cg),
                    .to_gphi => try temp.toRegClass(false, .gphi, cg),
                    .to_mut_gphi => try temp.toRegClass(true, .gphi, cg),
                    .x87, .to_x87 => try temp.toRegClass(false, .x87, cg),
                    .mut_x87, .to_mut_x87 => try temp.toRegClass(true, .x87, cg),
                    .mmx, .to_mmx => try temp.toRegClass(false, .mmx, cg),
                    .mut_mmx, .to_mut_mmx => try temp.toRegClass(true, .mmx, cg),
                    .sse, .to_sse => try temp.toRegClass(false, .sse, cg),
                    .mut_sse, .to_mut_sse => try temp.toRegClass(true, .sse, cg),
                };
            }
        };
    };

    const TempSpec = struct {
        type: Type = .noreturn,
        kind: Kind,

        const unused: TempSpec = .{ .kind = .unused };

        const Kind = union(enum) {
            unused,
            any,
            none,
            undef,
            cc: Condition,
            ptest_cc: struct { ref: Select.Operand.Ref, not: bool = false, all: u1 },
            imm: i32,
            ref: Select.Operand.Ref,
            reg: Register,
            reg_pair: [2]Register,
            param_gpr: CallConvRegSpec,
            param_gpr_pair: CallConvRegSpec,
            param_sse: CallConvRegSpec,
            ret_gpr: CallConvRegSpec,
            ret_gpr_pair: CallConvRegSpec,
            ret_sse: CallConvRegSpec,
            rc: Register.Class,
            rc_pair: Register.Class,
            mut_rc: struct { ref: Select.Operand.Ref, rc: Register.Class },
            ref_mask: struct { ref: Select.Operand.Ref, info: MaskInfo },
            rc_mask: struct { rc: Register.Class, info: MaskInfo },
            mut_rc_mask: struct { ref: Select.Operand.Ref, rc: Register.Class, info: MaskInfo },
            mem,
            mem_of_type: Select.Operand.Ref,
            smin_mem: ConstSpec,
            smax_mem: ConstSpec,
            slimit_delta_mem: ConstSpec,
            umin_mem: ConstSpec,
            umax_mem: ConstSpec,
            umax_delta_mem: ConstSpec,
            @"0x1p63_mem": ConstSpec,
            f64_0x1p52_0x1p84_mem,
            u32_0x1p52_hi_0x1p84_hi_0_0_mem,
            f32_0_0x1p64_mem,
            pshufb_splat_mem: struct { of: Memory.Size = .none, size: Memory.Size },
            pshufb_trunc_mem: struct { of: Memory.Size = .none, from: Memory.Size, to: Memory.Size },
            pand_trunc_mem: struct { from: Memory.Size, to: Memory.Size },
            pand_mask_mem: struct { ref: Select.Operand.Ref, invert: bool = false },
            ptest_mask_mem: Select.Operand.Ref,
            pshufb_bswap_mem: struct { repeat: u4 = 1, size: Memory.Size, smear: u4 = 1 },
            bits_mem: enum { forward, reverse },
            splat_int_mem: struct { ref: Select.Operand.Ref, inside: enum { umin, smin, smax } = .umin, outside: enum { smin, smax } },
            splat_float_mem: struct { ref: Select.Operand.Ref, inside: enum { zero } = .zero, outside: f16 },
            frame: FrameIndex,
            lazy_sym: struct { kind: link.File.LazySymbol.Kind, ref: Select.Operand.Ref = .none },
            extern_func: [*:0]const u8,

            const ConstSpec = struct {
                ref: Select.Operand.Ref = .none,
                to_signedness: ?std.builtin.Signedness = null,
                vectorize_to: ?Memory.Size = null,
            };

            const CallConvRegSpec = struct {
                cc: Case.CallConv,
                after: u2,
                at: u2,

                fn tag(spec: CallConvRegSpec, cg: *const CodeGen) std.builtin.CallingConvention.Tag {
                    return switch (spec.cc) {
                        .none => unreachable,
                        .ccc => cg.target.cCallingConvention().?,
                        .zigcc => .auto,
                    };
                }

                fn index(spec: CallConvRegSpec, cg: *const CodeGen) u2 {
                    return switch (spec.tag(cg)) {
                        .auto, .x86_64_sysv => spec.after,
                        .x86_64_win => spec.at,
                        else => unreachable,
                    };
                }
            };

            fn lock(kind: Kind, cg: *CodeGen) ![2]?RegisterLock {
                var reg_locks: [2]?RegisterLock = @splat(null);
                const regs: [2]Register = switch (kind) {
                    else => return reg_locks,
                    .reg => |reg| .{ reg, .none },
                    .reg_pair => |regs| regs,
                    .param_gpr => |param_spec| abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.index(cg)..][0..1].* ++ .{.none},
                    .param_gpr_pair => |param_spec| abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.index(cg)..][0..2].*,
                    .param_sse => |param_spec| abi.getCAbiSseParamRegs(param_spec.tag(cg), cg.target)[param_spec.index(cg)..][0..1].* ++ .{.none},
                    .ret_gpr => |ret_spec| abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index(cg)..][0..1].* ++ .{.none},
                    .ret_gpr_pair => |ret_spec| abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index(cg)..][0..2].*,
                    .ret_sse => |ret_spec| abi.getCAbiSseReturnRegs(ret_spec.tag(cg))[ret_spec.index(cg)..][0..1].* ++ .{.none},
                };
                for (regs, &reg_locks) |reg, *reg_lock| {
                    if (reg == .none) continue;
                    const reg_index = RegisterManager.indexOfRegIntoTracked(reg) orelse continue;
                    try cg.register_manager.getRegIndex(reg_index, null);
                    reg_lock.* = cg.register_manager.lockRegIndex(reg_index);
                }
                return reg_locks;
            }
        };

        fn create(spec: TempSpec, s: *const Select) InnerError!struct { Temp, bool } {
            const cg = s.cg;
            const pt = cg.pt;
            return switch (spec.kind) {
                .unused => .{ undefined, false },
                .any => .{ try cg.tempAlloc(spec.type), true },
                .none => .{ try cg.tempInit(spec.type, .none), true },
                .undef => .{ try cg.tempInit(spec.type, .undef), true },
                .imm => |imm| .{ try cg.tempInit(spec.type, .{ .immediate = @bitCast(@as(i64, imm)) }), true },
                .cc => |cc| .{ try cg.tempInit(spec.type, .{ .eflags = cc }), true },
                .ptest_cc => |cc_spec| {
                    const ccs: [2]Condition = .{ .z, .c };
                    const cc = ccs[cc_spec.all ^ @intFromBool(cc_spec.ref.valueOf(s).register_mask.info.inverted)];
                    return .{ try cg.tempInit(spec.type, .{ .eflags = switch (cc_spec.not) {
                        false => cc,
                        true => cc.negate(),
                    } }), true };
                },
                .ref => |ref| .{ ref.tempOf(s), false },
                .reg => |reg| .{ try cg.tempInit(spec.type, .{ .register = reg }), true },
                .reg_pair => |regs| .{ try cg.tempInit(spec.type, .{ .register_pair = regs }), true },
                .param_gpr => |param_spec| .{ try cg.tempInit(spec.type, .{
                    .register = abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.index(cg)],
                }), true },
                .param_gpr_pair => |param_spec| .{ try cg.tempInit(spec.type, .{
                    .register_pair = abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.index(cg)..][0..2].*,
                }), true },
                .param_sse => |param_spec| .{ try cg.tempInit(spec.type, .{
                    .register = abi.getCAbiSseParamRegs(param_spec.tag(cg), cg.target)[param_spec.index(cg)],
                }), true },
                .ret_gpr => |ret_spec| .{ try cg.tempInit(spec.type, .{
                    .register = abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index(cg)],
                }), true },
                .ret_gpr_pair => |ret_spec| .{ try cg.tempInit(spec.type, .{
                    .register_pair = abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index(cg)..][0..2].*,
                }), true },
                .ret_sse => |ret_spec| .{ try cg.tempInit(spec.type, .{
                    .register = abi.getCAbiSseReturnRegs(ret_spec.tag(cg))[ret_spec.index(cg)],
                }), true },
                .rc => |rc| .{ try cg.tempAllocReg(spec.type, regSetForRegClass(rc)), true },
                .rc_pair => |rc| .{ try cg.tempAllocRegPair(spec.type, regSetForRegClass(rc)), true },
                .mut_rc => |ref_rc| {
                    const temp = ref_rc.ref.tempOf(s);
                    if (temp.isMut(cg)) switch (temp.tracking(cg).short) {
                        .register => |reg| if (reg.isClass(ref_rc.rc)) return .{ temp, false },
                        .register_offset => |reg_off| if (reg_off.off == 0 and reg_off.reg.isClass(ref_rc.rc)) return .{ temp, false },
                        else => {},
                    };
                    return .{ try cg.tempAllocReg(spec.type, regSetForRegClass(ref_rc.rc)), true };
                },
                .ref_mask => |ref_mask| .{ ref_mask.ref.tempOf(s), false },
                .rc_mask => |rc_mask| .{ try cg.tempAllocReg(spec.type, regSetForRegClass(rc_mask.rc)), true },
                .mut_rc_mask => |ref_rc_mask| {
                    const temp = ref_rc_mask.ref.tempOf(s);
                    if (temp.isMut(cg)) switch (temp.tracking(cg).short) {
                        .register => |reg| if (reg.isClass(ref_rc_mask.rc)) return .{ temp, false },
                        .register_offset => |reg_off| if (reg_off.off == 0 and reg_off.reg.isClass(ref_rc_mask.rc)) return .{ temp, false },
                        else => {},
                    };
                    return .{ try cg.tempAllocReg(spec.type, regSetForRegClass(ref_rc_mask.rc)), true };
                },
                .mem => .{ try cg.tempAllocMem(spec.type), true },
                .mem_of_type => |ref| .{ try cg.tempAllocMem(ref.typeOf(s)), true },
                .smin_mem,
                .smax_mem,
                .slimit_delta_mem,
                .umin_mem,
                .umax_mem,
                .umax_delta_mem,
                .@"0x1p63_mem",
                => |const_spec| {
                    const zcu = pt.zcu;
                    const ip = &zcu.intern_pool;
                    const ty = if (const_spec.ref == .none) spec.type else const_spec.ref.typeOf(s);
                    const vector_len, const scalar_ty: Type = switch (ip.indexToKey(ty.toIntern())) {
                        else => .{ null, ty },
                        .vector_type => |vector_type| .{ vector_type.len, .fromInterned(vector_type.child) },
                    };
                    const res_vector_len: ?u32 = if (const_spec.vectorize_to) |vectorize_to| switch (vectorize_to) {
                        .none => null,
                        else => @intCast(@divExact(@divExact(vectorize_to.bitSize(cg.target), 8), scalar_ty.abiSize(pt.zcu))),
                    } else vector_len;
                    const res_scalar_ty, const res_scalar_val: Value = res_scalar: switch (scalar_ty.toIntern()) {
                        .bool_type => .{ scalar_ty, .fromInterned(switch (spec.kind) {
                            else => unreachable,
                            .smin_mem, .umax_mem => .bool_true,
                            .smax_mem, .umin_mem => .bool_false,
                        }) },
                        else => {
                            const scalar_info: std.builtin.Type.Int = cg.intInfo(scalar_ty) orelse .{
                                .signedness = .signed,
                                .bits = cg.floatBits(scalar_ty).?,
                            };
                            const res_scalar_info: std.builtin.Type.Int = .{
                                .signedness = const_spec.to_signedness orelse scalar_info.signedness,
                                .bits = switch (spec.kind) {
                                    else => scalar_info.bits,
                                    .slimit_delta_mem, .umax_delta_mem => cg.intInfo(spec.type.scalarType(zcu)).?.bits,
                                },
                            };
                            const res_scalar_ty = try pt.intType(res_scalar_info.signedness, res_scalar_info.bits);

                            if (res_scalar_info.bits <= 64) {
                                const int_val: i64 = switch (spec.kind) {
                                    else => unreachable,
                                    .smin_mem => std.math.minInt(i64),
                                    .smax_mem => std.math.maxInt(i64),
                                    .slimit_delta_mem => std.math.maxInt(i64) -
                                        (@as(i64, std.math.maxInt(i64)) >> @intCast(res_scalar_info.bits - scalar_info.bits)),
                                    .umin_mem => 0,
                                    .umax_mem => -1,
                                    .umax_delta_mem => @bitCast(std.math.maxInt(u64) -
                                        (@as(u64, std.math.maxInt(u64)) >> @intCast(res_scalar_info.bits - scalar_info.bits))),
                                    .@"0x1p63_mem" => switch (res_scalar_info.bits) {
                                        else => unreachable,
                                        16 => @as(i64, @as(i16, @bitCast(@as(f16, 0x1p63)))) << 64 - 16,
                                        32 => @as(i64, @as(i32, @bitCast(@as(f32, 0x1p63)))) << 64 - 32,
                                        64 => @as(i64, @as(i64, @bitCast(@as(f64, 0x1p63)))) << 64 - 64,
                                    },
                                };
                                const shift: u6 = @intCast(64 - res_scalar_info.bits);
                                break :res_scalar .{ res_scalar_ty, switch (res_scalar_info.signedness) {
                                    .signed => try pt.intValue_i64(res_scalar_ty, int_val >> shift),
                                    .unsigned => try pt.intValue_u64(res_scalar_ty, @as(u64, @bitCast(int_val)) >> shift),
                                } };
                            }

                            const ExpectedContents = [std.math.big.int.calcTwosCompLimbCount(1 << 10)]std.math.big.Limb;
                            var stack align(@max(@alignOf(ExpectedContents), @alignOf(std.heap.StackFallbackAllocator(0)))) =
                                std.heap.stackFallback(@sizeOf(ExpectedContents), cg.gpa);
                            const allocator = stack.get();
                            var res_big_int: std.math.big.int.Mutable = .{
                                .limbs = try allocator.alloc(
                                    std.math.big.Limb,
                                    std.math.big.int.calcTwosCompLimbCount(res_scalar_info.bits),
                                ),
                                .len = undefined,
                                .positive = undefined,
                            };
                            defer allocator.free(res_big_int.limbs);
                            switch (spec.kind) {
                                else => unreachable,
                                .smin_mem, .smax_mem, .umin_mem, .umax_mem => res_big_int.setTwosCompIntLimit(switch (spec.kind) {
                                    else => unreachable,
                                    .smin_mem, .umin_mem => .min,
                                    .smax_mem, .umax_mem => .max,
                                }, switch (spec.kind) {
                                    else => unreachable,
                                    .smin_mem, .smax_mem => .signed,
                                    .umin_mem, .umax_mem => .unsigned,
                                }, res_scalar_info.bits),
                                .slimit_delta_mem, .umax_delta_mem => {
                                    var big_int: std.math.big.int.Mutable = .{
                                        .limbs = try allocator.alloc(
                                            std.math.big.Limb,
                                            std.math.big.int.calcTwosCompLimbCount(scalar_info.bits),
                                        ),
                                        .len = undefined,
                                        .positive = undefined,
                                    };
                                    defer allocator.free(big_int.limbs);
                                    const signedness: std.builtin.Signedness = switch (spec.kind) {
                                        else => unreachable,
                                        .slimit_delta_mem => .signed,
                                        .umax_delta_mem => .unsigned,
                                    };
                                    big_int.setTwosCompIntLimit(.max, signedness, scalar_info.bits);
                                    res_big_int.setTwosCompIntLimit(.max, signedness, res_scalar_info.bits);
                                    res_big_int.sub(res_big_int.toConst(), big_int.toConst());
                                },
                                .@"0x1p63_mem" => switch (res_scalar_info.bits) {
                                    else => unreachable,
                                    80 => res_big_int.set(@as(u80, @bitCast(@as(f80, 0x1p63)))),
                                    128 => res_big_int.set(@as(u128, @bitCast(@as(f128, 0x1p63)))),
                                },
                            }
                            res_big_int.truncate(res_big_int.toConst(), res_scalar_info.signedness, res_scalar_info.bits);
                            break :res_scalar .{ res_scalar_ty, try pt.intValue_big(res_scalar_ty, res_big_int.toConst()) };
                        },
                    };
                    const res_val = if (res_vector_len) |len| try pt.aggregateSplatValue(try pt.vectorType(.{
                        .len = len,
                        .child = res_scalar_ty.toIntern(),
                    }), res_scalar_val) else res_scalar_val;
                    return .{ try cg.tempMemFromValue(res_val), true };
                },
                .f64_0x1p52_0x1p84_mem => .{ try cg.tempMemFromValue(
                    try pt.aggregateValue(try pt.vectorType(.{ .len = 2, .child = .f64_type }), &.{
                        (try pt.floatValue(.f64, @as(f64, 0x1p52))).toIntern(),
                        (try pt.floatValue(.f64, @as(f64, 0x1p84))).toIntern(),
                    }),
                ), true },
                .u32_0x1p52_hi_0x1p84_hi_0_0_mem => .{ try cg.tempMemFromValue(
                    try pt.aggregateValue(try pt.vectorType(.{ .len = 4, .child = .u32_type }), &(.{
                        (try pt.intValue(.u32, @as(u64, @bitCast(@as(f64, 0x1p52))) >> 32)).toIntern(),
                        (try pt.intValue(.u32, @as(u64, @bitCast(@as(f64, 0x1p84))) >> 32)).toIntern(),
                    } ++ .{(try pt.intValue(.u32, 0)).toIntern()} ** 2)),
                ), true },
                .f32_0_0x1p64_mem => .{ try cg.tempMemFromValue(
                    try pt.aggregateValue(try pt.vectorType(.{ .len = 2, .child = .f32_type }), &.{
                        (try pt.floatValue(.f32, @as(f32, 0))).toIntern(),
                        (try pt.floatValue(.f32, @as(f32, 0x1p64))).toIntern(),
                    }),
                ), true },
                .pshufb_splat_mem => |splat_spec| {
                    const zcu = pt.zcu;
                    assert(spec.type.isVector(zcu) and spec.type.childType(zcu).toIntern() == .u8_type);
                    var elem_buf: [32]u8 = @splat(1 << 7);
                    const elems = elem_buf[0..spec.type.vectorLen(zcu)];
                    const of_bytes: u6 = @intCast(switch (splat_spec.of) {
                        .none => elems.len,
                        else => |of| @divExact(of.bitSize(cg.target), 8),
                    });
                    const size_bytes: u6 = @intCast(@divExact(splat_spec.size.bitSize(cg.target), 8));
                    var index: u6 = 0;
                    while (index < of_bytes) : (index += size_bytes) for (0..size_bytes) |byte_off| {
                        elems[index + byte_off] = @as(u4, @truncate(byte_off));
                    };
                    return .{ try cg.tempMemFromValue(.fromInterned(try pt.intern(.{ .aggregate = .{
                        .ty = spec.type.toIntern(),
                        .storage = .{ .bytes = try zcu.intern_pool.getOrPutString(zcu.gpa, pt.tid, elems, .maybe_embedded_nulls) },
                    } }))), true };
                },
                .pshufb_trunc_mem => |trunc_spec| {
                    const zcu = pt.zcu;
                    assert(spec.type.isVector(zcu) and spec.type.childType(zcu).toIntern() == .u8_type);
                    var elem_buf: [32]u8 = @splat(1 << 7);
                    const elems = elem_buf[0..spec.type.vectorLen(zcu)];
                    const of_bytes: u6 = @intCast(switch (trunc_spec.of) {
                        .none => elems.len,
                        else => |of| @divExact(of.bitSize(cg.target), 8),
                    });
                    const from_bytes: u5 = @intCast(@divExact(trunc_spec.from.bitSize(cg.target), 8));
                    const to_bytes: u5 = @intCast(@divExact(trunc_spec.to.bitSize(cg.target), 8));
                    var from_index: u6 = 0;
                    var to_index: u6 = 0;
                    while (from_index < of_bytes) : ({
                        from_index += from_bytes;
                        switch (from_index % 16) {
                            0 => to_index = from_index,
                            else => to_index += to_bytes,
                        }
                    }) for (0..to_bytes) |byte_off| {
                        elems[to_index + byte_off] = @as(u4, @truncate(from_index + byte_off));
                    };
                    return .{ try cg.tempMemFromValue(.fromInterned(try pt.intern(.{ .aggregate = .{
                        .ty = spec.type.toIntern(),
                        .storage = .{ .bytes = try zcu.intern_pool.getOrPutString(zcu.gpa, pt.tid, elems, .maybe_embedded_nulls) },
                    } }))), true };
                },
                .pand_trunc_mem => |trunc_spec| {
                    const zcu = pt.zcu;
                    assert(spec.type.isVector(zcu) and spec.type.childType(zcu).toIntern() == .u8_type);
                    var elem_buf: [32]u8 = @splat(0);
                    const elems = elem_buf[0..spec.type.vectorLen(zcu)];
                    const from_bytes: u6 = @intCast(@divExact(trunc_spec.from.bitSize(cg.target), 8));
                    const to_bytes: u6 = @intCast(@divExact(trunc_spec.to.bitSize(cg.target), 8));
                    var index: u6 = 0;
                    while (index < elems.len) : (index += from_bytes) @memset(elems[index..][0..to_bytes], std.math.maxInt(u8));
                    return .{ try cg.tempMemFromValue(.fromInterned(try pt.intern(.{ .aggregate = .{
                        .ty = spec.type.toIntern(),
                        .storage = .{ .bytes = try zcu.intern_pool.getOrPutString(zcu.gpa, pt.tid, elems, .maybe_embedded_nulls) },
                    } }))), true };
                },
                .pand_mask_mem => |mask_spec| {
                    const zcu = pt.zcu;
                    assert(spec.type.isVector(zcu) and spec.type.childType(zcu).toIntern() == .u8_type);
                    const ref_ty = mask_spec.ref.typeOf(s);
                    assert(ref_ty.isVector(zcu));
                    var elem_buf: [64]u8 = undefined;
                    const elems = elem_buf[0..spec.type.vectorLen(zcu)];
                    const mask_len: usize = @intCast((cg.unalignedSize(ref_ty) - 1) % elems.len + 1);
                    const invert_mask: u8 = switch (mask_spec.invert) {
                        false => std.math.minInt(u8),
                        true => std.math.maxInt(u8),
                    };
                    @memset(elems[0..mask_len], ~invert_mask);
                    @memset(elems[mask_len..], invert_mask);
                    return .{ try cg.tempMemFromValue(.fromInterned(try pt.intern(.{ .aggregate = .{
                        .ty = spec.type.toIntern(),
                        .storage = .{ .bytes = try zcu.intern_pool.getOrPutString(zcu.gpa, pt.tid, elems, .maybe_embedded_nulls) },
                    } }))), true };
                },
                .ptest_mask_mem => |mask_ref| {
                    const zcu = pt.zcu;
                    assert(spec.type.isVector(zcu) and spec.type.childType(zcu).toIntern() == .u8_type);
                    const ref_ty = mask_ref.typeOf(s);
                    assert(ref_ty.isVector(zcu) and ref_ty.childType(zcu).toIntern() == .bool_type);
                    const mask_info = mask_ref.valueOf(s).register_mask.info;
                    var elem_buf: [64]u8 = @splat(0);
                    const elems = elem_buf[0..spec.type.vectorLen(zcu)];
                    const elem_bytes: u6 = @intCast(@divExact(mask_info.scalar.bitSize(cg.target), 8));
                    var index: u7 = 0;
                    for (0..@intCast(ref_ty.vectorLen(zcu))) |_| {
                        switch (mask_info.kind) {
                            .sign => {
                                @memset(elems[index..][0 .. elem_bytes - 1], std.math.minInt(u8));
                                elems[index + elem_bytes - 1] = @bitCast(@as(i8, std.math.minInt(i8)));
                            },
                            .all => @memset(elems[index..][0..elem_bytes], std.math.maxInt(u8)),
                        }
                        index += elem_bytes;
                    }
                    return .{ try cg.tempMemFromValue(.fromInterned(try pt.intern(.{ .aggregate = .{
                        .ty = spec.type.toIntern(),
                        .storage = .{ .bytes = try zcu.intern_pool.getOrPutString(zcu.gpa, pt.tid, elems, .maybe_embedded_nulls) },
                    } }))), true };
                },
                .pshufb_bswap_mem => |bswap_spec| {
                    const zcu = pt.zcu;
                    assert(spec.type.isVector(zcu) and spec.type.childType(zcu).toIntern() == .u8_type);
                    var elem_buf: [32]u8 = @splat(1 << 7);
                    const elems = elem_buf[0..spec.type.vectorLen(zcu)];
                    const len: usize = @intCast(@divExact(bswap_spec.size.bitSize(cg.target), 8));
                    var to_index: u6 = 0;
                    for (0..bswap_spec.repeat) |_| for (0..len) |from_index| {
                        @memset(elems[to_index..][0..bswap_spec.smear], @intCast(len - 1 - from_index));
                        to_index += bswap_spec.smear;
                    };
                    return .{ try cg.tempMemFromValue(.fromInterned(try pt.intern(.{ .aggregate = .{
                        .ty = spec.type.toIntern(),
                        .storage = .{ .bytes = try zcu.intern_pool.getOrPutString(zcu.gpa, pt.tid, elems, .maybe_embedded_nulls) },
                    } }))), true };
                },
                .bits_mem => |direction| {
                    const zcu = pt.zcu;
                    assert(spec.type.isVector(zcu) and spec.type.childType(zcu).toIntern() == .u8_type);
                    var bytes: [32]u8 = undefined;
                    const elems = bytes[0..spec.type.vectorLen(zcu)];
                    for (elems, 0..) |*elem, index| elem.* = switch (direction) {
                        .forward => @as(u8, 1 << 0) << @truncate(index),
                        .reverse => @as(u8, 1 << 7) >> @truncate(index),
                    };
                    return .{ try cg.tempMemFromValue(.fromInterned(try pt.intern(.{ .aggregate = .{
                        .ty = spec.type.toIntern(),
                        .storage = .{ .bytes = try zcu.intern_pool.getOrPutString(zcu.gpa, pt.tid, elems, .maybe_embedded_nulls) },
                    } }))), true };
                },
                .splat_int_mem => |splat_spec| {
                    const zcu = pt.zcu;
                    const elem_ty = spec.type.scalarType(zcu);
                    const elem_bits = cg.intInfo(elem_ty).?.bits;
                    const ref_ty = splat_spec.ref.typeOf(s);
                    assert(ref_ty.isVector(zcu) and cg.intInfo(ref_ty.childType(zcu)).?.bits <= elem_bits);
                    var elem_buf: [64]InternPool.Index = undefined;
                    const elems = elem_buf[0..if (elem_ty.toIntern() == spec.type.toIntern()) 1 else spec.type.vectorLen(zcu)];
                    const inside_len = (ref_ty.vectorLen(zcu) - 1) % elems.len + 1;
                    @memset(elems[0..inside_len], (try pt.intValue(elem_ty, @as(i64, switch (splat_spec.inside) {
                        .umin => 0,
                        .smin => std.math.minInt(i64),
                        .smax => std.math.maxInt(i64),
                    }) >> @intCast(64 - elem_bits))).toIntern());
                    @memset(elems[inside_len..], (try pt.intValue(elem_ty, @as(i64, switch (splat_spec.outside) {
                        .smin => std.math.minInt(i64),
                        .smax => std.math.maxInt(i64),
                    }) >> @intCast(64 - elem_bits))).toIntern());
                    if (elems.len == 1) return .{ try cg.tempMemFromValue(.fromInterned(elems[0])), true };
                    const mem_size = cg.unalignedSize(spec.type);
                    return .{ try cg.tempMemFromAlignedValue(
                        if (mem_size < 16) .fromByteUnits(mem_size) else .none,
                        try pt.aggregateValue(if (mem_size < 16) try pt.arrayType(.{
                            .len = elems.len,
                            .child = elem_ty.toIntern(),
                        }) else spec.type, elems),
                    ), true };
                },
                .splat_float_mem => |splat_spec| {
                    const zcu = pt.zcu;
                    assert(spec.type.isVector(zcu));
                    const elem_ty = spec.type.childType(zcu);
                    assert(cg.floatBits(elem_ty) != null);
                    const ref_ty = splat_spec.ref.typeOf(s);
                    assert(ref_ty.isVector(zcu) and ref_ty.childType(zcu).toIntern() == elem_ty.toIntern());
                    var elem_buf: [@divExact(64, 2)]InternPool.Index = undefined;
                    const elems = elem_buf[0..spec.type.vectorLen(zcu)];
                    const inside_len = (ref_ty.vectorLen(zcu) - 1) % elems.len + 1;
                    @memset(elems[0..inside_len], (try pt.floatValue(elem_ty, @as(f16, switch (splat_spec.inside) {
                        .zero => 0.0,
                    }))).toIntern());
                    @memset(elems[inside_len..], (try pt.floatValue(elem_ty, splat_spec.outside)).toIntern());
                    return .{ try cg.tempMemFromValue(try pt.aggregateValue(spec.type, elems)), true };
                },
                .frame => |frame_index| .{ try cg.tempInit(spec.type, .{ .load_frame = .{
                    .index = frame_index,
                    .off = switch (frame_index) {
                        .call_frame => switch (cg.target.cCallingConvention().?) {
                            .x86_64_sysv => 0,
                            .x86_64_win => win64_shadow_space,
                            else => unreachable,
                        },
                        else => 0,
                    },
                } }), true },
                .lazy_sym => |lazy_symbol_spec| {
                    const ip = &pt.zcu.intern_pool;
                    const ty = if (lazy_symbol_spec.ref == .none) spec.type else lazy_symbol_spec.ref.typeOf(s);
                    return .{ try cg.tempInit(.usize, .{ .lea_lazy_sym = .{
                        .kind = lazy_symbol_spec.kind,
                        .ty = switch (ip.indexToKey(ty.toIntern())) {
                            .inferred_error_set_type => |func_index| switch (ip.funcIesResolvedUnordered(func_index)) {
                                .none => unreachable,
                                else => |ty_index| ty_index,
                            },
                            else => ty.toIntern(),
                        },
                    } }), true };
                },
                .extern_func => |extern_func_spec| .{ try cg.tempInit(spec.type, .{ .lea_extern_func = try cg.addString(std.mem.span(extern_func_spec)) }), true },
            };
        }

        fn finish(spec: TempSpec, temp: *Temp, cg: *CodeGen) InnerError!void {
            switch (spec.kind) {
                else => {},
                inline .rc_mask, .mut_rc_mask, .ref_mask => |mask| temp.asMask(mask.info, cg),
            }
            cg.temp_type[@intFromEnum(temp.unwrap(cg).temp)] = spec.type;
        }
    };

    const Instruction = struct {
        Label,
        Mir.Inst.Fixes,
        Mir.Inst.Tag,
        Select.Operand,
        Select.Operand,
        Select.Operand,
        Select.Operand,
    };
    const Label = enum { @"0:", @"1:", @"2:", @"3:", @"4:", @"_", pseudo };
    const Operand = struct {
        flags: packed struct(u32) {
            tag: Tag,
            adjust: Adjust = .none,
            base: Ref.Sized = .none,
            index: packed struct(u7) {
                ref: Ref,
                scale: Memory.Scale = .@"1",
            } = .{ .ref = .none },
            unused: u1 = 0,
        },
        imm: i32 = 0,

        const Tag = enum(u3) {
            none,
            label,
            ref,
            simm,
            uimm,
            lea,
            mem,
        };
        const Adjust = packed struct(u12) {
            sign: enum(u1) { neg, pos },
            lhs: enum(u6) {
                none,
                ptr_size,
                ptr_bit_size,
                size,
                src0_size,
                dst0_size,
                delta_size,
                delta_elem_size,
                unaligned_size,
                unaligned_size_add_elem_size,
                unaligned_size_sub_elem_size,
                unaligned_size_sub_2_elem_size,
                bit_size,
                src0_bit_size,
                @"8_size_sub_bit_size",
                len,
                elem_limbs,
                elem_size,
                src0_elem_size,
                dst0_elem_size,
                src0_elem_size_mul_src1,
                vector_index,
                src1,
                src1_sub_bit_size,
                log2_src0_elem_size,
                elem_mask,
                smin,
                smax,
                umax,
                smin_shr_src1,
                smax_shr_src1,
                umax_shr_src1,
                repeat,
            },
            op: enum(u3) { mul, div, div_8_down, rem_8_mul, up_2_mul, up_32_mul },
            rhs: Memory.Scale,

            const none: Adjust = .{ .sign = .pos, .lhs = .none, .op = .mul, .rhs = .@"1" };
            const sub_ptr_size: Adjust = .{ .sign = .neg, .lhs = .ptr_size, .op = .mul, .rhs = .@"1" };
            const add_ptr_bit_size: Adjust = .{ .sign = .pos, .lhs = .ptr_bit_size, .op = .mul, .rhs = .@"1" };
            const add_size: Adjust = .{ .sign = .pos, .lhs = .size, .op = .mul, .rhs = .@"1" };
            const add_size_div_4: Adjust = .{ .sign = .pos, .lhs = .size, .op = .div, .rhs = .@"4" };
            const add_size_div_8: Adjust = .{ .sign = .pos, .lhs = .size, .op = .div, .rhs = .@"8" };
            const sub_size_div_8: Adjust = .{ .sign = .neg, .lhs = .size, .op = .div, .rhs = .@"8" };
            const sub_size_div_4: Adjust = .{ .sign = .neg, .lhs = .size, .op = .div, .rhs = .@"4" };
            const sub_size: Adjust = .{ .sign = .neg, .lhs = .size, .op = .mul, .rhs = .@"1" };
            const sub_src0_size_div_8: Adjust = .{ .sign = .neg, .lhs = .src0_size, .op = .div, .rhs = .@"8" };
            const sub_src0_size: Adjust = .{ .sign = .neg, .lhs = .src0_size, .op = .mul, .rhs = .@"1" };
            const add_src0_size: Adjust = .{ .sign = .pos, .lhs = .src0_size, .op = .mul, .rhs = .@"1" };
            const add_8_src0_size: Adjust = .{ .sign = .pos, .lhs = .src0_size, .op = .mul, .rhs = .@"8" };
            const add_dst0_size: Adjust = .{ .sign = .pos, .lhs = .dst0_size, .op = .mul, .rhs = .@"1" };
            const add_delta_size_div_8: Adjust = .{ .sign = .pos, .lhs = .delta_size, .op = .div, .rhs = .@"8" };
            const add_delta_elem_size: Adjust = .{ .sign = .pos, .lhs = .delta_elem_size, .op = .mul, .rhs = .@"1" };
            const add_delta_elem_size_div_8: Adjust = .{ .sign = .pos, .lhs = .delta_elem_size, .op = .div, .rhs = .@"8" };
            const add_unaligned_size: Adjust = .{ .sign = .pos, .lhs = .unaligned_size, .op = .mul, .rhs = .@"1" };
            const add_unaligned_size_up_2: Adjust = .{ .sign = .pos, .lhs = .unaligned_size, .op = .up_2_mul, .rhs = .@"1" };
            const add_unaligned_size_up_4: Adjust = .{ .sign = .pos, .lhs = .unaligned_size, .op = .up_2_mul, .rhs = .@"2" };
            const add_unaligned_size_up_8: Adjust = .{ .sign = .pos, .lhs = .unaligned_size, .op = .up_2_mul, .rhs = .@"4" };
            const add_unaligned_size_up_16: Adjust = .{ .sign = .pos, .lhs = .unaligned_size, .op = .up_2_mul, .rhs = .@"8" };
            const add_unaligned_size_up_32: Adjust = .{ .sign = .pos, .lhs = .unaligned_size, .op = .up_32_mul, .rhs = .@"1" };
            const sub_unaligned_size: Adjust = .{ .sign = .neg, .lhs = .unaligned_size, .op = .mul, .rhs = .@"1" };
            const add_unaligned_size_add_elem_size: Adjust = .{ .sign = .pos, .lhs = .unaligned_size_add_elem_size, .op = .mul, .rhs = .@"1" };
            const add_unaligned_size_sub_elem_size: Adjust = .{ .sign = .pos, .lhs = .unaligned_size_sub_elem_size, .op = .mul, .rhs = .@"1" };
            const add_unaligned_size_sub_2_elem_size: Adjust = .{ .sign = .pos, .lhs = .unaligned_size_sub_2_elem_size, .op = .mul, .rhs = .@"1" };
            const add_2_bit_size: Adjust = .{ .sign = .pos, .lhs = .bit_size, .op = .mul, .rhs = .@"2" };
            const add_bit_size: Adjust = .{ .sign = .pos, .lhs = .bit_size, .op = .mul, .rhs = .@"1" };
            const add_bit_size_rem_8: Adjust = .{ .sign = .pos, .lhs = .bit_size, .op = .rem_8_mul, .rhs = .@"1" };
            const add_bit_size_rem_64: Adjust = .{ .sign = .pos, .lhs = .bit_size, .op = .rem_8_mul, .rhs = .@"8" };
            const add_bit_size_div_8: Adjust = .{ .sign = .pos, .lhs = .bit_size, .op = .div, .rhs = .@"8" };
            const add_bit_size_div_8_down_1: Adjust = .{ .sign = .pos, .lhs = .bit_size, .op = .div_8_down, .rhs = .@"1" };
            const add_bit_size_div_8_down_2: Adjust = .{ .sign = .pos, .lhs = .bit_size, .op = .div_8_down, .rhs = .@"2" };
            const add_bit_size_div_8_down_8: Adjust = .{ .sign = .pos, .lhs = .bit_size, .op = .div_8_down, .rhs = .@"8" };
            const sub_bit_size_rem_64: Adjust = .{ .sign = .neg, .lhs = .bit_size, .op = .rem_8_mul, .rhs = .@"8" };
            const sub_bit_size: Adjust = .{ .sign = .neg, .lhs = .bit_size, .op = .mul, .rhs = .@"1" };
            const add_src0_bit_size: Adjust = .{ .sign = .pos, .lhs = .src0_bit_size, .op = .mul, .rhs = .@"1" };
            const sub_src0_bit_size: Adjust = .{ .sign = .neg, .lhs = .src0_bit_size, .op = .mul, .rhs = .@"1" };
            const add_bit_size_sub_8_size: Adjust = .{ .sign = .neg, .lhs = .@"8_size_sub_bit_size", .op = .mul, .rhs = .@"1" };
            const add_8_len: Adjust = .{ .sign = .pos, .lhs = .len, .op = .mul, .rhs = .@"8" };
            const add_4_len: Adjust = .{ .sign = .pos, .lhs = .len, .op = .mul, .rhs = .@"4" };
            const add_3_len: Adjust = .{ .sign = .pos, .lhs = .len, .op = .mul, .rhs = .@"3" };
            const add_2_len: Adjust = .{ .sign = .pos, .lhs = .len, .op = .mul, .rhs = .@"2" };
            const add_len: Adjust = .{ .sign = .pos, .lhs = .len, .op = .mul, .rhs = .@"1" };
            const sub_len: Adjust = .{ .sign = .neg, .lhs = .len, .op = .mul, .rhs = .@"1" };
            const add_elem_limbs: Adjust = .{ .sign = .pos, .lhs = .elem_limbs, .op = .mul, .rhs = .@"1" };
            const add_elem_size: Adjust = .{ .sign = .pos, .lhs = .elem_size, .op = .mul, .rhs = .@"1" };
            const add_elem_size_div_8: Adjust = .{ .sign = .pos, .lhs = .elem_size, .op = .div, .rhs = .@"8" };
            const sub_elem_size_div_8: Adjust = .{ .sign = .neg, .lhs = .elem_size, .op = .div, .rhs = .@"8" };
            const sub_elem_size_div_4: Adjust = .{ .sign = .neg, .lhs = .elem_size, .op = .div, .rhs = .@"4" };
            const add_src0_elem_size: Adjust = .{ .sign = .pos, .lhs = .src0_elem_size, .op = .mul, .rhs = .@"1" };
            const add_2_src0_elem_size: Adjust = .{ .sign = .pos, .lhs = .src0_elem_size, .op = .mul, .rhs = .@"2" };
            const add_4_src0_elem_size: Adjust = .{ .sign = .pos, .lhs = .src0_elem_size, .op = .mul, .rhs = .@"4" };
            const add_8_src0_elem_size: Adjust = .{ .sign = .pos, .lhs = .src0_elem_size, .op = .mul, .rhs = .@"8" };
            const add_src0_elem_size_div_8: Adjust = .{ .sign = .pos, .lhs = .src0_elem_size, .op = .div, .rhs = .@"8" };
            const sub_src0_elem_size_div_8: Adjust = .{ .sign = .neg, .lhs = .src0_elem_size, .op = .div, .rhs = .@"8" };
            const sub_src0_elem_size: Adjust = .{ .sign = .neg, .lhs = .src0_elem_size, .op = .mul, .rhs = .@"1" };
            const add_src0_elem_size_mul_src1: Adjust = .{ .sign = .pos, .lhs = .src0_elem_size_mul_src1, .op = .mul, .rhs = .@"1" };
            const sub_src0_elem_size_mul_src1: Adjust = .{ .sign = .neg, .lhs = .src0_elem_size_mul_src1, .op = .mul, .rhs = .@"1" };
            const add_vector_index: Adjust = .{ .sign = .pos, .lhs = .vector_index, .op = .mul, .rhs = .@"1" };
            const add_vector_index_rem_32: Adjust = .{ .sign = .pos, .lhs = .vector_index, .op = .rem_8_mul, .rhs = .@"4" };
            const add_vector_index_div_8_down_4: Adjust = .{ .sign = .pos, .lhs = .vector_index, .op = .div_8_down, .rhs = .@"4" };
            const add_dst0_elem_size: Adjust = .{ .sign = .pos, .lhs = .dst0_elem_size, .op = .mul, .rhs = .@"1" };
            const sub_dst0_elem_size: Adjust = .{ .sign = .neg, .lhs = .dst0_elem_size, .op = .mul, .rhs = .@"1" };
            const add_src1_div_8_down_4: Adjust = .{ .sign = .pos, .lhs = .src1, .op = .div_8_down, .rhs = .@"4" };
            const add_src1: Adjust = .{ .sign = .pos, .lhs = .src1, .op = .mul, .rhs = .@"1" };
            const add_src1_rem_32: Adjust = .{ .sign = .pos, .lhs = .src1, .op = .rem_8_mul, .rhs = .@"4" };
            const add_src1_rem_64: Adjust = .{ .sign = .pos, .lhs = .src1, .op = .rem_8_mul, .rhs = .@"8" };
            const add_src1_sub_bit_size: Adjust = .{ .sign = .pos, .lhs = .src1_sub_bit_size, .op = .mul, .rhs = .@"1" };
            const add_log2_src0_elem_size: Adjust = .{ .sign = .pos, .lhs = .log2_src0_elem_size, .op = .mul, .rhs = .@"1" };
            const elem_mask: Adjust = .{ .sign = .pos, .lhs = .elem_mask, .op = .mul, .rhs = .@"1" };
            const add_smin: Adjust = .{ .sign = .pos, .lhs = .smin, .op = .mul, .rhs = .@"1" };
            const add_2_smin: Adjust = .{ .sign = .pos, .lhs = .smin, .op = .mul, .rhs = .@"2" };
            const sub_smin: Adjust = .{ .sign = .neg, .lhs = .smin, .op = .mul, .rhs = .@"1" };
            const add_smax: Adjust = .{ .sign = .pos, .lhs = .smax, .op = .mul, .rhs = .@"1" };
            const add_umax: Adjust = .{ .sign = .pos, .lhs = .umax, .op = .mul, .rhs = .@"1" };
            const sub_umax: Adjust = .{ .sign = .neg, .lhs = .umax, .op = .mul, .rhs = .@"1" };
            const add_smax_shr_src1: Adjust = .{ .sign = .pos, .lhs = .smax_shr_src1, .op = .mul, .rhs = .@"1" };
            const add_umax_shr_src1: Adjust = .{ .sign = .pos, .lhs = .umax_shr_src1, .op = .mul, .rhs = .@"1" };
            const repeat: Adjust = .{ .sign = .pos, .lhs = .repeat, .op = .mul, .rhs = .@"1" };
        };
        const Ref = enum(u5) {
            tmp0,
            tmp1,
            tmp2,
            tmp3,
            tmp4,
            tmp5,
            tmp6,
            tmp7,
            tmp8,
            tmp9,
            tmp10,
            dst0,
            dst1,
            src0,
            src1,
            src2,
            none,

            const Sized = packed struct(u9) {
                ref: Ref,
                size: Memory.Size,

                const none: Sized = .{ .ref = .none, .size = .none };

                const tmp0: Sized = .{ .ref = .tmp0, .size = .none };
                const tmp0l: Sized = .{ .ref = .tmp0, .size = .low_byte };
                const tmp0h: Sized = .{ .ref = .tmp0, .size = .high_byte };
                const tmp0b: Sized = .{ .ref = .tmp0, .size = .byte };
                const tmp0w: Sized = .{ .ref = .tmp0, .size = .word };
                const tmp0d: Sized = .{ .ref = .tmp0, .size = .dword };
                const tmp0p: Sized = .{ .ref = .tmp0, .size = .ptr };
                const tmp0g: Sized = .{ .ref = .tmp0, .size = .gpr };
                const tmp0q: Sized = .{ .ref = .tmp0, .size = .qword };
                const tmp0t: Sized = .{ .ref = .tmp0, .size = .tbyte };
                const tmp0x: Sized = .{ .ref = .tmp0, .size = .xword };
                const tmp0y: Sized = .{ .ref = .tmp0, .size = .yword };

                const tmp1: Sized = .{ .ref = .tmp1, .size = .none };
                const tmp1l: Sized = .{ .ref = .tmp1, .size = .low_byte };
                const tmp1h: Sized = .{ .ref = .tmp1, .size = .high_byte };
                const tmp1b: Sized = .{ .ref = .tmp1, .size = .byte };
                const tmp1w: Sized = .{ .ref = .tmp1, .size = .word };
                const tmp1d: Sized = .{ .ref = .tmp1, .size = .dword };
                const tmp1p: Sized = .{ .ref = .tmp1, .size = .ptr };
                const tmp1g: Sized = .{ .ref = .tmp1, .size = .gpr };
                const tmp1q: Sized = .{ .ref = .tmp1, .size = .qword };
                const tmp1t: Sized = .{ .ref = .tmp1, .size = .tbyte };
                const tmp1x: Sized = .{ .ref = .tmp1, .size = .xword };
                const tmp1y: Sized = .{ .ref = .tmp1, .size = .yword };

                const tmp2: Sized = .{ .ref = .tmp2, .size = .none };
                const tmp2l: Sized = .{ .ref = .tmp2, .size = .low_byte };
                const tmp2h: Sized = .{ .ref = .tmp2, .size = .high_byte };
                const tmp2b: Sized = .{ .ref = .tmp2, .size = .byte };
                const tmp2w: Sized = .{ .ref = .tmp2, .size = .word };
                const tmp2d: Sized = .{ .ref = .tmp2, .size = .dword };
                const tmp2p: Sized = .{ .ref = .tmp2, .size = .ptr };
                const tmp2g: Sized = .{ .ref = .tmp2, .size = .gpr };
                const tmp2q: Sized = .{ .ref = .tmp2, .size = .qword };
                const tmp2t: Sized = .{ .ref = .tmp2, .size = .tbyte };
                const tmp2x: Sized = .{ .ref = .tmp2, .size = .xword };
                const tmp2y: Sized = .{ .ref = .tmp2, .size = .yword };

                const tmp3: Sized = .{ .ref = .tmp3, .size = .none };
                const tmp3l: Sized = .{ .ref = .tmp3, .size = .low_byte };
                const tmp3h: Sized = .{ .ref = .tmp3, .size = .high_byte };
                const tmp3b: Sized = .{ .ref = .tmp3, .size = .byte };
                const tmp3w: Sized = .{ .ref = .tmp3, .size = .word };
                const tmp3d: Sized = .{ .ref = .tmp3, .size = .dword };
                const tmp3p: Sized = .{ .ref = .tmp3, .size = .ptr };
                const tmp3g: Sized = .{ .ref = .tmp3, .size = .gpr };
                const tmp3q: Sized = .{ .ref = .tmp3, .size = .qword };
                const tmp3t: Sized = .{ .ref = .tmp3, .size = .tbyte };
                const tmp3x: Sized = .{ .ref = .tmp3, .size = .xword };
                const tmp3y: Sized = .{ .ref = .tmp3, .size = .yword };

                const tmp4: Sized = .{ .ref = .tmp4, .size = .none };
                const tmp4l: Sized = .{ .ref = .tmp4, .size = .low_byte };
                const tmp4h: Sized = .{ .ref = .tmp4, .size = .high_byte };
                const tmp4b: Sized = .{ .ref = .tmp4, .size = .byte };
                const tmp4w: Sized = .{ .ref = .tmp4, .size = .word };
                const tmp4d: Sized = .{ .ref = .tmp4, .size = .dword };
                const tmp4p: Sized = .{ .ref = .tmp4, .size = .ptr };
                const tmp4g: Sized = .{ .ref = .tmp4, .size = .gpr };
                const tmp4q: Sized = .{ .ref = .tmp4, .size = .qword };
                const tmp4t: Sized = .{ .ref = .tmp4, .size = .tbyte };
                const tmp4x: Sized = .{ .ref = .tmp4, .size = .xword };
                const tmp4y: Sized = .{ .ref = .tmp4, .size = .yword };

                const tmp5: Sized = .{ .ref = .tmp5, .size = .none };
                const tmp5l: Sized = .{ .ref = .tmp5, .size = .low_byte };
                const tmp5h: Sized = .{ .ref = .tmp5, .size = .high_byte };
                const tmp5b: Sized = .{ .ref = .tmp5, .size = .byte };
                const tmp5w: Sized = .{ .ref = .tmp5, .size = .word };
                const tmp5d: Sized = .{ .ref = .tmp5, .size = .dword };
                const tmp5p: Sized = .{ .ref = .tmp5, .size = .ptr };
                const tmp5g: Sized = .{ .ref = .tmp5, .size = .gpr };
                const tmp5q: Sized = .{ .ref = .tmp5, .size = .qword };
                const tmp5t: Sized = .{ .ref = .tmp5, .size = .tbyte };
                const tmp5x: Sized = .{ .ref = .tmp5, .size = .xword };
                const tmp5y: Sized = .{ .ref = .tmp5, .size = .yword };

                const tmp6: Sized = .{ .ref = .tmp6, .size = .none };
                const tmp6l: Sized = .{ .ref = .tmp6, .size = .low_byte };
                const tmp6h: Sized = .{ .ref = .tmp6, .size = .high_byte };
                const tmp6b: Sized = .{ .ref = .tmp6, .size = .byte };
                const tmp6w: Sized = .{ .ref = .tmp6, .size = .word };
                const tmp6d: Sized = .{ .ref = .tmp6, .size = .dword };
                const tmp6p: Sized = .{ .ref = .tmp6, .size = .ptr };
                const tmp6g: Sized = .{ .ref = .tmp6, .size = .gpr };
                const tmp6q: Sized = .{ .ref = .tmp6, .size = .qword };
                const tmp6t: Sized = .{ .ref = .tmp6, .size = .tbyte };
                const tmp6x: Sized = .{ .ref = .tmp6, .size = .xword };
                const tmp6y: Sized = .{ .ref = .tmp6, .size = .yword };

                const tmp7: Sized = .{ .ref = .tmp7, .size = .none };
                const tmp7l: Sized = .{ .ref = .tmp7, .size = .low_byte };
                const tmp7h: Sized = .{ .ref = .tmp7, .size = .high_byte };
                const tmp7b: Sized = .{ .ref = .tmp7, .size = .byte };
                const tmp7w: Sized = .{ .ref = .tmp7, .size = .word };
                const tmp7d: Sized = .{ .ref = .tmp7, .size = .dword };
                const tmp7p: Sized = .{ .ref = .tmp7, .size = .ptr };
                const tmp7g: Sized = .{ .ref = .tmp7, .size = .gpr };
                const tmp7q: Sized = .{ .ref = .tmp7, .size = .qword };
                const tmp7t: Sized = .{ .ref = .tmp7, .size = .tbyte };
                const tmp7x: Sized = .{ .ref = .tmp7, .size = .xword };
                const tmp7y: Sized = .{ .ref = .tmp7, .size = .yword };

                const tmp8: Sized = .{ .ref = .tmp8, .size = .none };
                const tmp8l: Sized = .{ .ref = .tmp8, .size = .low_byte };
                const tmp8h: Sized = .{ .ref = .tmp8, .size = .high_byte };
                const tmp8b: Sized = .{ .ref = .tmp8, .size = .byte };
                const tmp8w: Sized = .{ .ref = .tmp8, .size = .word };
                const tmp8d: Sized = .{ .ref = .tmp8, .size = .dword };
                const tmp8p: Sized = .{ .ref = .tmp8, .size = .ptr };
                const tmp8g: Sized = .{ .ref = .tmp8, .size = .gpr };
                const tmp8q: Sized = .{ .ref = .tmp8, .size = .qword };
                const tmp8t: Sized = .{ .ref = .tmp8, .size = .tbyte };
                const tmp8x: Sized = .{ .ref = .tmp8, .size = .xword };
                const tmp8y: Sized = .{ .ref = .tmp8, .size = .yword };

                const tmp9: Sized = .{ .ref = .tmp9, .size = .none };
                const tmp9l: Sized = .{ .ref = .tmp9, .size = .low_byte };
                const tmp9h: Sized = .{ .ref = .tmp9, .size = .high_byte };
                const tmp9b: Sized = .{ .ref = .tmp9, .size = .byte };
                const tmp9w: Sized = .{ .ref = .tmp9, .size = .word };
                const tmp9d: Sized = .{ .ref = .tmp9, .size = .dword };
                const tmp9p: Sized = .{ .ref = .tmp9, .size = .ptr };
                const tmp9g: Sized = .{ .ref = .tmp9, .size = .gpr };
                const tmp9q: Sized = .{ .ref = .tmp9, .size = .qword };
                const tmp9t: Sized = .{ .ref = .tmp9, .size = .tbyte };
                const tmp9x: Sized = .{ .ref = .tmp9, .size = .xword };
                const tmp9y: Sized = .{ .ref = .tmp9, .size = .yword };

                const tmp10: Sized = .{ .ref = .tmp10, .size = .none };
                const tmp10l: Sized = .{ .ref = .tmp10, .size = .low_byte };
                const tmp10h: Sized = .{ .ref = .tmp10, .size = .high_byte };
                const tmp10b: Sized = .{ .ref = .tmp10, .size = .byte };
                const tmp10w: Sized = .{ .ref = .tmp10, .size = .word };
                const tmp10d: Sized = .{ .ref = .tmp10, .size = .dword };
                const tmp10p: Sized = .{ .ref = .tmp10, .size = .ptr };
                const tmp10g: Sized = .{ .ref = .tmp10, .size = .gpr };
                const tmp10q: Sized = .{ .ref = .tmp10, .size = .qword };
                const tmp10t: Sized = .{ .ref = .tmp10, .size = .tbyte };
                const tmp10x: Sized = .{ .ref = .tmp10, .size = .xword };
                const tmp10y: Sized = .{ .ref = .tmp10, .size = .yword };

                const dst0: Sized = .{ .ref = .dst0, .size = .none };
                const dst0l: Sized = .{ .ref = .dst0, .size = .low_byte };
                const dst0h: Sized = .{ .ref = .dst0, .size = .high_byte };
                const dst0b: Sized = .{ .ref = .dst0, .size = .byte };
                const dst0w: Sized = .{ .ref = .dst0, .size = .word };
                const dst0d: Sized = .{ .ref = .dst0, .size = .dword };
                const dst0p: Sized = .{ .ref = .dst0, .size = .ptr };
                const dst0g: Sized = .{ .ref = .dst0, .size = .gpr };
                const dst0q: Sized = .{ .ref = .dst0, .size = .qword };
                const dst0t: Sized = .{ .ref = .dst0, .size = .tbyte };
                const dst0x: Sized = .{ .ref = .dst0, .size = .xword };
                const dst0y: Sized = .{ .ref = .dst0, .size = .yword };

                const dst1: Sized = .{ .ref = .dst1, .size = .none };
                const dst1l: Sized = .{ .ref = .dst1, .size = .low_byte };
                const dst1h: Sized = .{ .ref = .dst1, .size = .high_byte };
                const dst1b: Sized = .{ .ref = .dst1, .size = .byte };
                const dst1w: Sized = .{ .ref = .dst1, .size = .word };
                const dst1d: Sized = .{ .ref = .dst1, .size = .dword };
                const dst1p: Sized = .{ .ref = .dst1, .size = .ptr };
                const dst1g: Sized = .{ .ref = .dst1, .size = .gpr };
                const dst1q: Sized = .{ .ref = .dst1, .size = .qword };
                const dst1t: Sized = .{ .ref = .dst1, .size = .tbyte };
                const dst1x: Sized = .{ .ref = .dst1, .size = .xword };
                const dst1y: Sized = .{ .ref = .dst1, .size = .yword };

                const src0: Sized = .{ .ref = .src0, .size = .none };
                const src0l: Sized = .{ .ref = .src0, .size = .low_byte };
                const src0h: Sized = .{ .ref = .src0, .size = .high_byte };
                const src0b: Sized = .{ .ref = .src0, .size = .byte };
                const src0w: Sized = .{ .ref = .src0, .size = .word };
                const src0d: Sized = .{ .ref = .src0, .size = .dword };
                const src0p: Sized = .{ .ref = .src0, .size = .ptr };
                const src0g: Sized = .{ .ref = .src0, .size = .gpr };
                const src0q: Sized = .{ .ref = .src0, .size = .qword };
                const src0t: Sized = .{ .ref = .src0, .size = .tbyte };
                const src0x: Sized = .{ .ref = .src0, .size = .xword };
                const src0y: Sized = .{ .ref = .src0, .size = .yword };

                const src1: Sized = .{ .ref = .src1, .size = .none };
                const src1l: Sized = .{ .ref = .src1, .size = .low_byte };
                const src1h: Sized = .{ .ref = .src1, .size = .high_byte };
                const src1b: Sized = .{ .ref = .src1, .size = .byte };
                const src1w: Sized = .{ .ref = .src1, .size = .word };
                const src1d: Sized = .{ .ref = .src1, .size = .dword };
                const src1p: Sized = .{ .ref = .src1, .size = .ptr };
                const src1g: Sized = .{ .ref = .src1, .size = .gpr };
                const src1q: Sized = .{ .ref = .src1, .size = .qword };
                const src1t: Sized = .{ .ref = .src1, .size = .tbyte };
                const src1x: Sized = .{ .ref = .src1, .size = .xword };
                const src1y: Sized = .{ .ref = .src1, .size = .yword };

                const src2: Sized = .{ .ref = .src2, .size = .none };
                const src2l: Sized = .{ .ref = .src2, .size = .low_byte };
                const src2h: Sized = .{ .ref = .src2, .size = .high_byte };
                const src2b: Sized = .{ .ref = .src2, .size = .byte };
                const src2w: Sized = .{ .ref = .src2, .size = .word };
                const src2d: Sized = .{ .ref = .src2, .size = .dword };
                const src2p: Sized = .{ .ref = .src2, .size = .ptr };
                const src2g: Sized = .{ .ref = .src2, .size = .gpr };
                const src2q: Sized = .{ .ref = .src2, .size = .qword };
                const src2t: Sized = .{ .ref = .src2, .size = .tbyte };
                const src2x: Sized = .{ .ref = .src2, .size = .xword };
                const src2y: Sized = .{ .ref = .src2, .size = .yword };
            };

            fn typeOf(ref: Ref, s: *const Select) Type {
                return s.types[@intFromEnum(ref)];
            }

            fn tempOf(ref: Ref, s: *const Select) Temp {
                return s.temps[@intFromEnum(ref)];
            }

            fn valueOf(ref: Ref, s: *const Select) MCValue {
                return switch (ref) {
                    .none => .none,
                    else => s.temps[@intFromEnum(ref)].tracking(s.cg).short,
                };
            }
        };

        const @"_": Select.Operand = .{ .flags = .{ .tag = .none } };

        const @"0b": Select.Operand = .{ .flags = .{ .tag = .label }, .imm = ~@as(i32, 0) };
        const @"0f": Select.Operand = .{ .flags = .{ .tag = .label }, .imm = @as(i32, 0) };
        const @"1b": Select.Operand = .{ .flags = .{ .tag = .label }, .imm = ~@as(i32, 1) };
        const @"1f": Select.Operand = .{ .flags = .{ .tag = .label }, .imm = @as(i32, 1) };
        const @"2b": Select.Operand = .{ .flags = .{ .tag = .label }, .imm = ~@as(i32, 2) };
        const @"2f": Select.Operand = .{ .flags = .{ .tag = .label }, .imm = @as(i32, 2) };
        const @"3b": Select.Operand = .{ .flags = .{ .tag = .label }, .imm = ~@as(i32, 3) };
        const @"3f": Select.Operand = .{ .flags = .{ .tag = .label }, .imm = @as(i32, 3) };
        const @"4b": Select.Operand = .{ .flags = .{ .tag = .label }, .imm = ~@as(i32, 4) };
        const @"4f": Select.Operand = .{ .flags = .{ .tag = .label }, .imm = @as(i32, 4) };

        const tmp0l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp0l } };
        const tmp0h: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp0h } };
        const tmp0b: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp0b } };
        const tmp0w: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp0w } };
        const tmp0d: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp0d } };
        const tmp0p: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp0p } };
        const tmp0g: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp0g } };
        const tmp0q: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp0q } };
        const tmp0t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp0t } };
        const tmp0x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp0x } };
        const tmp0y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp0y } };
        const tmp0w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp0w }, .imm = 1 };
        const tmp0d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp0d }, .imm = 1 };
        const tmp0p0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp0p }, .imm = 1 };
        const tmp0q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp0q }, .imm = 1 };
        const tmp0w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp0w }, .imm = 2 };
        const tmp0d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp0d }, .imm = 2 };
        const tmp0p1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp0p }, .imm = 2 };
        const tmp0q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp0q }, .imm = 2 };

        const tmp1l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp1l } };
        const tmp1h: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp1h } };
        const tmp1b: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp1b } };
        const tmp1w: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp1w } };
        const tmp1d: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp1d } };
        const tmp1p: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp1p } };
        const tmp1g: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp1g } };
        const tmp1q: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp1q } };
        const tmp1t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp1t } };
        const tmp1x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp1x } };
        const tmp1y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp1y } };
        const tmp1w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp1w }, .imm = 1 };
        const tmp1d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp1d }, .imm = 1 };
        const tmp1p0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp1p }, .imm = 1 };
        const tmp1q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp1q }, .imm = 1 };
        const tmp1w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp1w }, .imm = 2 };
        const tmp1d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp1d }, .imm = 2 };
        const tmp1p1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp1p }, .imm = 2 };
        const tmp1q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp1q }, .imm = 2 };

        const tmp2l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp2l } };
        const tmp2h: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp2h } };
        const tmp2b: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp2b } };
        const tmp2w: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp2w } };
        const tmp2d: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp2d } };
        const tmp2p: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp2p } };
        const tmp2g: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp2g } };
        const tmp2q: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp2q } };
        const tmp2t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp2t } };
        const tmp2x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp2x } };
        const tmp2y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp2y } };
        const tmp2w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp2w }, .imm = 1 };
        const tmp2d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp2d }, .imm = 1 };
        const tmp2p0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp2p }, .imm = 1 };
        const tmp2q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp2q }, .imm = 1 };
        const tmp2w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp2w }, .imm = 2 };
        const tmp2d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp2d }, .imm = 2 };
        const tmp2p1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp2p }, .imm = 2 };
        const tmp2q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp2q }, .imm = 2 };

        const tmp3l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp3l } };
        const tmp3h: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp3h } };
        const tmp3b: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp3b } };
        const tmp3w: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp3w } };
        const tmp3d: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp3d } };
        const tmp3p: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp3p } };
        const tmp3g: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp3g } };
        const tmp3q: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp3q } };
        const tmp3t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp3t } };
        const tmp3x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp3x } };
        const tmp3y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp3y } };
        const tmp3w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp3w }, .imm = 1 };
        const tmp3d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp3d }, .imm = 1 };
        const tmp3p0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp3p }, .imm = 1 };
        const tmp3q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp3q }, .imm = 1 };
        const tmp3w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp3w }, .imm = 2 };
        const tmp3d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp3d }, .imm = 2 };
        const tmp3p1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp3p }, .imm = 2 };
        const tmp3q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp3q }, .imm = 2 };

        const tmp4l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp4l } };
        const tmp4h: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp4h } };
        const tmp4b: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp4b } };
        const tmp4w: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp4w } };
        const tmp4d: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp4d } };
        const tmp4p: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp4p } };
        const tmp4g: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp4g } };
        const tmp4q: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp4q } };
        const tmp4t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp4t } };
        const tmp4x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp4x } };
        const tmp4y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp4y } };
        const tmp4w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp4w }, .imm = 1 };
        const tmp4d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp4d }, .imm = 1 };
        const tmp4p0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp4p }, .imm = 1 };
        const tmp4q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp4q }, .imm = 1 };
        const tmp4w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp4w }, .imm = 2 };
        const tmp4d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp4d }, .imm = 2 };
        const tmp4p1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp4p }, .imm = 2 };
        const tmp4q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp4q }, .imm = 2 };

        const tmp5l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp5l } };
        const tmp5h: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp5h } };
        const tmp5b: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp5b } };
        const tmp5w: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp5w } };
        const tmp5d: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp5d } };
        const tmp5p: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp5p } };
        const tmp5g: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp5g } };
        const tmp5q: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp5q } };
        const tmp5t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp5t } };
        const tmp5x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp5x } };
        const tmp5y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp5y } };
        const tmp5w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp5w }, .imm = 1 };
        const tmp5d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp5d }, .imm = 1 };
        const tmp5p0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp5p }, .imm = 1 };
        const tmp5q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp5q }, .imm = 1 };
        const tmp5w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp5w }, .imm = 2 };
        const tmp5d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp5d }, .imm = 2 };
        const tmp5p1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp5p }, .imm = 2 };
        const tmp5q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp5q }, .imm = 2 };

        const tmp6l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp6l } };
        const tmp6h: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp6h } };
        const tmp6b: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp6b } };
        const tmp6w: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp6w } };
        const tmp6d: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp6d } };
        const tmp6p: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp6p } };
        const tmp6g: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp6g } };
        const tmp6q: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp6q } };
        const tmp6t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp6t } };
        const tmp6x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp6x } };
        const tmp6y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp6y } };
        const tmp6w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp6w }, .imm = 1 };
        const tmp6d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp6d }, .imm = 1 };
        const tmp6p0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp6p }, .imm = 1 };
        const tmp6q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp6q }, .imm = 1 };
        const tmp6w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp6w }, .imm = 2 };
        const tmp6d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp6d }, .imm = 2 };
        const tmp6p1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp6p }, .imm = 2 };
        const tmp6q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp6q }, .imm = 2 };

        const tmp7l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp7l } };
        const tmp7h: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp7h } };
        const tmp7b: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp7b } };
        const tmp7w: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp7w } };
        const tmp7d: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp7d } };
        const tmp7p: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp7p } };
        const tmp7g: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp7g } };
        const tmp7q: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp7q } };
        const tmp7t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp7t } };
        const tmp7x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp7x } };
        const tmp7y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp7y } };
        const tmp7w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp7w }, .imm = 1 };
        const tmp7d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp7d }, .imm = 1 };
        const tmp7p0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp7p }, .imm = 1 };
        const tmp7q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp7q }, .imm = 1 };
        const tmp7w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp7w }, .imm = 2 };
        const tmp7d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp7d }, .imm = 2 };
        const tmp7p1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp7p }, .imm = 2 };
        const tmp7q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp7q }, .imm = 2 };

        const tmp8l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp8l } };
        const tmp8h: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp8h } };
        const tmp8b: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp8b } };
        const tmp8w: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp8w } };
        const tmp8d: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp8d } };
        const tmp8p: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp8p } };
        const tmp8g: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp8g } };
        const tmp8q: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp8q } };
        const tmp8t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp8t } };
        const tmp8x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp8x } };
        const tmp8y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp8y } };
        const tmp8w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp8w }, .imm = 1 };
        const tmp8d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp8d }, .imm = 1 };
        const tmp8p0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp8p }, .imm = 1 };
        const tmp8q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp8q }, .imm = 1 };
        const tmp8w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp8w }, .imm = 2 };
        const tmp8d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp8d }, .imm = 2 };
        const tmp8p1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp8p }, .imm = 2 };
        const tmp8q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp8q }, .imm = 2 };

        const tmp9l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp9l } };
        const tmp9h: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp9h } };
        const tmp9b: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp9b } };
        const tmp9w: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp9w } };
        const tmp9d: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp9d } };
        const tmp9p: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp9p } };
        const tmp9g: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp9g } };
        const tmp9q: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp9q } };
        const tmp9t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp9t } };
        const tmp9x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp9x } };
        const tmp9y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp9y } };
        const tmp9w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp9w }, .imm = 1 };
        const tmp9d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp9d }, .imm = 1 };
        const tmp9p0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp9p }, .imm = 1 };
        const tmp9q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp9q }, .imm = 1 };
        const tmp9w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp9w }, .imm = 2 };
        const tmp9d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp9d }, .imm = 2 };
        const tmp9p1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp9p }, .imm = 2 };
        const tmp9q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp9q }, .imm = 2 };

        const tmp10l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp10l } };
        const tmp10h: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp10h } };
        const tmp10b: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp10b } };
        const tmp10w: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp10w } };
        const tmp10d: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp10d } };
        const tmp10p: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp10p } };
        const tmp10g: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp10g } };
        const tmp10q: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp10q } };
        const tmp10t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp10t } };
        const tmp10x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp10x } };
        const tmp10y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp10y } };
        const tmp10w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp10w }, .imm = 1 };
        const tmp10d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp10d }, .imm = 1 };
        const tmp10p0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp10p }, .imm = 1 };
        const tmp10q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp10q }, .imm = 1 };
        const tmp10w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp10w }, .imm = 2 };
        const tmp10d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp10d }, .imm = 2 };
        const tmp10p1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp10p }, .imm = 2 };
        const tmp10q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp10q }, .imm = 2 };

        const dst0l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst0l } };
        const dst0h: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst0h } };
        const dst0b: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst0b } };
        const dst0w: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst0w } };
        const dst0d: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst0d } };
        const dst0p: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst0p } };
        const dst0g: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst0g } };
        const dst0q: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst0q } };
        const dst0t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst0t } };
        const dst0x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst0x } };
        const dst0y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst0y } };
        const dst0w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst0w }, .imm = 1 };
        const dst0d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst0d }, .imm = 1 };
        const dst0p0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst0p }, .imm = 1 };
        const dst0q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst0q }, .imm = 1 };
        const dst0w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst0w }, .imm = 2 };
        const dst0d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst0d }, .imm = 2 };
        const dst0p1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst0p }, .imm = 2 };
        const dst0q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst0q }, .imm = 2 };

        const dst1l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst1l } };
        const dst1h: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst1h } };
        const dst1b: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst1b } };
        const dst1w: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst1w } };
        const dst1d: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst1d } };
        const dst1p: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst1p } };
        const dst1g: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst1g } };
        const dst1q: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst1q } };
        const dst1t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst1t } };
        const dst1x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst1x } };
        const dst1y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst1y } };
        const dst1w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst1w }, .imm = 1 };
        const dst1d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst1d }, .imm = 1 };
        const dst1p0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst1p }, .imm = 1 };
        const dst1q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst1q }, .imm = 1 };
        const dst1w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst1w }, .imm = 2 };
        const dst1d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst1d }, .imm = 2 };
        const dst1p1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst1p }, .imm = 2 };
        const dst1q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst1q }, .imm = 2 };

        const src0l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src0l } };
        const src0h: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src0h } };
        const src0b: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src0b } };
        const src0w: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src0w } };
        const src0d: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src0d } };
        const src0p: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src0p } };
        const src0g: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src0g } };
        const src0q: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src0q } };
        const src0t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src0t } };
        const src0x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src0x } };
        const src0y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src0y } };
        const src0w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src0w }, .imm = 1 };
        const src0d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src0d }, .imm = 1 };
        const src0p0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src0p }, .imm = 1 };
        const src0q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src0q }, .imm = 1 };
        const src0w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src0w }, .imm = 2 };
        const src0d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src0d }, .imm = 2 };
        const src0p1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src0p }, .imm = 2 };
        const src0q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src0q }, .imm = 2 };

        const src1l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src1l } };
        const src1h: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src1h } };
        const src1b: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src1b } };
        const src1w: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src1w } };
        const src1d: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src1d } };
        const src1p: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src1p } };
        const src1g: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src1g } };
        const src1q: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src1q } };
        const src1t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src1t } };
        const src1x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src1x } };
        const src1y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src1y } };
        const src1w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src1w }, .imm = 1 };
        const src1d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src1d }, .imm = 1 };
        const src1p0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src1p }, .imm = 1 };
        const src1q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src1q }, .imm = 1 };
        const src1w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src1w }, .imm = 2 };
        const src1d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src1d }, .imm = 2 };
        const src1p1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src1p }, .imm = 2 };
        const src1q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src1q }, .imm = 2 };

        const src2l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src2l } };
        const src2h: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src2h } };
        const src2b: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src2b } };
        const src2w: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src2w } };
        const src2d: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src2d } };
        const src2p: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src2p } };
        const src2g: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src2g } };
        const src2q: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src2q } };
        const src2t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src2t } };
        const src2x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src2x } };
        const src2y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src2y } };
        const src2w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src2w }, .imm = 1 };
        const src2d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src2d }, .imm = 1 };
        const src2p0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src2p }, .imm = 1 };
        const src2q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src2q }, .imm = 1 };
        const src2w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src2w }, .imm = 2 };
        const src2d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src2d }, .imm = 2 };
        const src2p1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src2p }, .imm = 2 };
        const src2q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src2q }, .imm = 2 };

        fn si(imm: i32) Select.Operand {
            return .{ .flags = .{ .tag = .simm }, .imm = imm };
        }
        fn sa(base: Ref.Sized, adjust: Adjust) Select.Operand {
            return .{ .flags = .{ .tag = .simm, .adjust = adjust, .base = base } };
        }
        fn sa2(base: Ref.Sized, index: Ref, adjust: Adjust) Select.Operand {
            return .{ .flags = .{ .tag = .simm, .adjust = adjust, .base = base, .index = .{ .ref = index } } };
        }
        fn sia(imm: i32, base: Ref.Sized, adjust: Adjust) Select.Operand {
            return .{ .flags = .{ .tag = .simm, .adjust = adjust, .base = base }, .imm = imm };
        }
        fn sia2(imm: i32, base: Ref.Sized, index: Ref, adjust: Adjust) Select.Operand {
            return .{ .flags = .{ .tag = .simm, .adjust = adjust, .base = base, .index = .{ .ref = index } }, .imm = imm };
        }
        fn ui(imm: u32) Select.Operand {
            return .{ .flags = .{ .tag = .uimm }, .imm = @bitCast(imm) };
        }
        fn ua(base: Ref.Sized, adjust: Adjust) Select.Operand {
            return .{ .flags = .{ .tag = .uimm, .adjust = adjust, .base = base } };
        }
        fn uia(imm: u32, base: Ref.Sized, adjust: Adjust) Select.Operand {
            return .{ .flags = .{ .tag = .uimm, .adjust = adjust, .base = base }, .imm = @bitCast(imm) };
        }
        fn uas(base: Ref.Sized, scale: Memory.Scale, adjust: Adjust) Select.Operand {
            return .{ .flags = .{ .tag = .uimm, .adjust = adjust, .base = base, .index = .{ .scale = scale } } };
        }

        fn rm(mode: bits.RoundMode) Select.Operand {
            return .{ .flags = .{ .tag = .uimm }, .imm = @intCast(mode.imm().unsigned) };
        }
        fn sp(pred: bits.SseFloatPredicate) Select.Operand {
            return .{ .flags = .{ .tag = .uimm }, .imm = @intCast(pred.imm().unsigned) };
        }
        fn vp(pred: bits.VexFloatPredicate) Select.Operand {
            return .{ .flags = .{ .tag = .uimm }, .imm = @intCast(pred.imm().unsigned) };
        }

        fn lea(base: Ref.Sized) Select.Operand {
            return .{
                .flags = .{
                    .tag = .lea,
                    .base = base,
                },
            };
        }
        fn leaa(base: Ref.Sized, adjust: Adjust) Select.Operand {
            return .{
                .flags = .{
                    .tag = .lea,
                    .adjust = adjust,
                    .base = base,
                },
            };
        }
        fn leaad(base: Ref.Sized, adjust: Adjust, disp: i32) Select.Operand {
            return .{
                .flags = .{
                    .tag = .lea,
                    .adjust = adjust,
                    .base = base,
                },
                .imm = disp,
            };
        }
        fn lead(base: Ref.Sized, disp: i32) Select.Operand {
            return .{
                .flags = .{
                    .tag = .lea,
                    .base = base,
                },
                .imm = disp,
            };
        }
        fn leai(base: Ref.Sized, index: Ref) Select.Operand {
            return .{
                .flags = .{
                    .tag = .lea,
                    .base = base,
                    .index = .{ .ref = index },
                },
            };
        }
        fn leaia(base: Ref.Sized, index: Ref, adjust: Adjust) Select.Operand {
            return .{
                .flags = .{
                    .tag = .lea,
                    .adjust = adjust,
                    .base = base,
                    .index = .{ .ref = index },
                },
            };
        }
        fn leaiad(base: Ref.Sized, index: Ref, adjust: Adjust, disp: i32) Select.Operand {
            return .{
                .flags = .{
                    .tag = .lea,
                    .adjust = adjust,
                    .base = base,
                    .index = .{ .ref = index },
                },
                .imm = disp,
            };
        }
        fn leaid(base: Ref.Sized, index: Ref, disp: i32) Select.Operand {
            return .{
                .flags = .{
                    .tag = .lea,
                    .base = base,
                    .index = .{ .ref = index },
                },
                .imm = disp,
            };
        }
        fn leasi(base: Ref.Sized, scale: Memory.Scale, index: Ref) Select.Operand {
            return .{
                .flags = .{
                    .tag = .lea,
                    .base = base,
                    .index = .{ .ref = index, .scale = scale },
                },
            };
        }
        fn leasia(base: Ref.Sized, scale: Memory.Scale, index: Ref, adjust: Adjust) Select.Operand {
            return .{
                .flags = .{
                    .tag = .lea,
                    .adjust = adjust,
                    .base = base,
                    .index = .{ .ref = index, .scale = scale },
                },
            };
        }
        fn leasid(base: Ref.Sized, scale: Memory.Scale, index: Ref, disp: i32) Select.Operand {
            return .{
                .flags = .{
                    .tag = .lea,
                    .base = base,
                    .index = .{ .ref = index, .scale = scale },
                },
                .imm = disp,
            };
        }
        fn leasiad(base: Ref.Sized, scale: Memory.Scale, index: Ref, adjust: Adjust, disp: i32) Select.Operand {
            return .{
                .flags = .{
                    .tag = .lea,
                    .adjust = adjust,
                    .base = base,
                    .index = .{ .ref = index, .scale = scale },
                },
                .imm = disp,
            };
        }

        fn mem(base: Ref.Sized) Select.Operand {
            return .{
                .flags = .{
                    .tag = .mem,
                    .base = base,
                },
            };
        }
        fn memd(base: Ref.Sized, disp: i32) Select.Operand {
            return .{
                .flags = .{
                    .tag = .mem,
                    .base = base,
                },
                .imm = disp,
            };
        }
        fn mema(base: Ref.Sized, adjust: Adjust) Select.Operand {
            return .{
                .flags = .{
                    .tag = .mem,
                    .adjust = adjust,
                    .base = base,
                },
            };
        }
        fn memad(base: Ref.Sized, adjust: Adjust, disp: i32) Select.Operand {
            return .{
                .flags = .{
                    .tag = .mem,
                    .adjust = adjust,
                    .base = base,
                },
                .imm = disp,
            };
        }
        fn memi(base: Ref.Sized, index: Ref) Select.Operand {
            return .{
                .flags = .{
                    .tag = .mem,
                    .base = base,
                    .index = .{ .ref = index },
                },
            };
        }
        fn memia(base: Ref.Sized, index: Ref, adjust: Adjust) Select.Operand {
            return .{
                .flags = .{
                    .tag = .mem,
                    .adjust = adjust,
                    .base = base,
                    .index = .{ .ref = index },
                },
            };
        }
        fn memiad(base: Ref.Sized, index: Ref, adjust: Adjust, disp: i32) Select.Operand {
            return .{
                .flags = .{
                    .tag = .mem,
                    .adjust = adjust,
                    .base = base,
                    .index = .{ .ref = index },
                },
                .imm = disp,
            };
        }
        fn memid(base: Ref.Sized, index: Ref, disp: i32) Select.Operand {
            return .{
                .flags = .{
                    .tag = .mem,
                    .base = base,
                    .index = .{ .ref = index },
                },
                .imm = disp,
            };
        }
        fn memsi(base: Ref.Sized, scale: Memory.Scale, index: Ref) Select.Operand {
            return .{
                .flags = .{
                    .tag = .mem,
                    .base = base,
                    .index = .{ .ref = index, .scale = scale },
                },
            };
        }
        fn memsia(base: Ref.Sized, scale: Memory.Scale, index: Ref, adjust: Adjust) Select.Operand {
            return .{
                .flags = .{
                    .tag = .mem,
                    .adjust = adjust,
                    .base = base,
                    .index = .{ .ref = index, .scale = scale },
                },
            };
        }
        fn memsid(base: Ref.Sized, scale: Memory.Scale, index: Ref, disp: i32) Select.Operand {
            return .{
                .flags = .{
                    .tag = .mem,
                    .base = base,
                    .index = .{ .ref = index, .scale = scale },
                },
                .imm = disp,
            };
        }
        fn memsiad(base: Ref.Sized, scale: Memory.Scale, index: Ref, adjust: Adjust, disp: i32) Select.Operand {
            return .{
                .flags = .{
                    .tag = .mem,
                    .adjust = adjust,
                    .base = base,
                    .index = .{ .ref = index, .scale = scale },
                },
                .imm = disp,
            };
        }

        fn adjustedImm(op: Select.Operand, comptime SignedImm: type, s: *const Select) SignedImm {
            const UnsignedImm = @Int(.unsigned, @typeInfo(SignedImm).int.bits);
            const lhs: SignedImm = lhs: switch (op.flags.adjust.lhs) {
                .none => 0,
                .ptr_size => @divExact(s.cg.target.ptrBitWidth(), 8),
                .ptr_bit_size => s.cg.target.ptrBitWidth(),
                .size => @intCast(op.flags.base.ref.typeOf(s).abiSize(s.cg.pt.zcu)),
                .src0_size => @intCast(Select.Operand.Ref.src0.typeOf(s).abiSize(s.cg.pt.zcu)),
                .dst0_size => @intCast(Select.Operand.Ref.dst0.typeOf(s).abiSize(s.cg.pt.zcu)),
                .delta_size => @intCast(@as(SignedImm, @intCast(op.flags.base.ref.typeOf(s).abiSize(s.cg.pt.zcu))) -
                    @as(SignedImm, @intCast(op.flags.index.ref.typeOf(s).abiSize(s.cg.pt.zcu)))),
                .delta_elem_size => @intCast(@as(SignedImm, @intCast(op.flags.base.ref.typeOf(s).elemType2(s.cg.pt.zcu).abiSize(s.cg.pt.zcu))) -
                    @as(SignedImm, @intCast(op.flags.index.ref.typeOf(s).elemType2(s.cg.pt.zcu).abiSize(s.cg.pt.zcu)))),
                .unaligned_size => @intCast(s.cg.unalignedSize(op.flags.base.ref.typeOf(s))),
                .unaligned_size_add_elem_size => {
                    const ty = op.flags.base.ref.typeOf(s);
                    break :lhs @intCast(s.cg.unalignedSize(ty) + ty.elemType2(s.cg.pt.zcu).abiSize(s.cg.pt.zcu));
                },
                .unaligned_size_sub_elem_size => {
                    const ty = op.flags.base.ref.typeOf(s);
                    break :lhs @intCast(s.cg.unalignedSize(ty) - ty.elemType2(s.cg.pt.zcu).abiSize(s.cg.pt.zcu));
                },
                .unaligned_size_sub_2_elem_size => {
                    const ty = op.flags.base.ref.typeOf(s);
                    break :lhs @intCast(s.cg.unalignedSize(ty) - ty.elemType2(s.cg.pt.zcu).abiSize(s.cg.pt.zcu) * 2);
                },
                .bit_size => @intCast(s.cg.nonBoolScalarBitSize(op.flags.base.ref.typeOf(s))),
                .src0_bit_size => @intCast(s.cg.nonBoolScalarBitSize(Select.Operand.Ref.src0.typeOf(s))),
                .@"8_size_sub_bit_size" => {
                    const ty = op.flags.base.ref.typeOf(s);
                    break :lhs @intCast(8 * ty.abiSize(s.cg.pt.zcu) - ty.bitSize(s.cg.pt.zcu));
                },
                .len => @intCast(op.flags.base.ref.typeOf(s).vectorLen(s.cg.pt.zcu)),
                .elem_limbs => @intCast(@divExact(
                    op.flags.base.ref.typeOf(s).scalarType(s.cg.pt.zcu).abiSize(s.cg.pt.zcu),
                    @divExact(op.flags.base.size.bitSize(s.cg.target), 8),
                )),
                .elem_size => @intCast(op.flags.base.ref.typeOf(s).elemType2(s.cg.pt.zcu).abiSize(s.cg.pt.zcu)),
                .src0_elem_size => @intCast(Select.Operand.Ref.src0.typeOf(s).elemType2(s.cg.pt.zcu).abiSize(s.cg.pt.zcu)),
                .dst0_elem_size => @intCast(Select.Operand.Ref.dst0.typeOf(s).elemType2(s.cg.pt.zcu).abiSize(s.cg.pt.zcu)),
                .src0_elem_size_mul_src1 => @intCast(Select.Operand.Ref.src0.typeOf(s).elemType2(s.cg.pt.zcu).abiSize(s.cg.pt.zcu) *
                    Select.Operand.Ref.src1.valueOf(s).immediate),
                .vector_index => switch (op.flags.base.ref.typeOf(s).ptrInfo(s.cg.pt.zcu).flags.vector_index) {
                    .none => unreachable,
                    else => |vector_index| @intFromEnum(vector_index),
                },
                .src1 => @intCast(Select.Operand.Ref.src1.valueOf(s).immediate),
                .src1_sub_bit_size => @as(SignedImm, @intCast(Select.Operand.Ref.src1.valueOf(s).immediate)) -
                    @as(SignedImm, @intCast(s.cg.nonBoolScalarBitSize(op.flags.base.ref.typeOf(s)))),
                .log2_src0_elem_size => @intCast(std.math.log2(Select.Operand.Ref.src0.typeOf(s).elemType2(s.cg.pt.zcu).abiSize(s.cg.pt.zcu))),
                .elem_mask => @as(u8, std.math.maxInt(u8)) >> @intCast(
                    8 - ((s.cg.unalignedSize(op.flags.base.ref.typeOf(s)) - 1) %
                        @divExact(op.flags.base.size.bitSize(s.cg.target), 8) + 1 >>
                        op.flags.index.scale.toLog2()),
                ),
                inline .smin, .smax, .umax, .smin_shr_src1, .smax_shr_src1, .umax_shr_src1 => |adjust| switch (op.flags.base.size) {
                    else => unreachable,
                    inline .none, .byte, .word, .dword, .qword => |size| {
                        const Imm = switch (adjust) {
                            else => comptime unreachable,
                            .smin, .smax, .smin_shr_src1, .smax_shr_src1 => SignedImm,
                            .umax, .umax_shr_src1 => UnsignedImm,
                        };
                        const RefImm = switch (size) {
                            else => comptime unreachable,
                            .none => Imm,
                            .byte, .word, .dword, .qword => @Int(
                                @typeInfo(Imm).int.signedness,
                                size.bitSize(undefined),
                            ),
                        };
                        break :lhs @bitCast(@as(Imm, @intCast(@as(RefImm, switch (adjust) {
                            else => comptime unreachable,
                            .smin, .smin_shr_src1 => std.math.minInt,
                            .smax, .umax, .smax_shr_src1, .umax_shr_src1 => std.math.maxInt,
                        }(RefImm)) >> @truncate(switch (adjust) {
                            else => comptime unreachable,
                            .smin, .smax, .umax => 0,
                            .smin_shr_src1, .smax_shr_src1, .umax_shr_src1 => Select.Operand.Ref.src1.valueOf(s).immediate,
                        } -% s.cg.nonBoolScalarBitSize(op.flags.base.ref.typeOf(s))))));
                    },
                },
                .repeat => switch (SignedImm) {
                    else => unreachable,
                    i64 => return @as(i64, op.imm) << 32 | @as(u32, @bitCast(op.imm)),
                },
            };
            const rhs = op.flags.adjust.rhs.toLog2();
            const op_res = op_res: switch (op.flags.adjust.op) {
                .mul => {
                    const op_res = @shlWithOverflow(lhs, rhs);
                    assert(op_res[1] == 0);
                    break :op_res op_res[0];
                },
                .div => @shrExact(lhs, rhs),
                .div_8_down => lhs >> 3 & @as(SignedImm, -1) << rhs,
                .rem_8_mul => lhs & ((@as(SignedImm, 8) << rhs) - 1),
                .up_2_mul => ((lhs - 1) & @as(SignedImm, -2) << rhs) + (@as(SignedImm, 2) << rhs),
                .up_32_mul => ((lhs - 1) & @as(SignedImm, -32) << rhs) + (@as(SignedImm, 32) << rhs),
            };
            const disp: SignedImm = @bitCast(@as(UnsignedImm, @as(u32, @bitCast(op.imm))));
            return switch (op.flags.adjust.sign) {
                .neg => disp - op_res,
                .pos => disp + op_res,
            };
        }

        fn lower(op: Select.Operand, s: *Select) InnerError!CodeGen.Operand {
            return switch (op.flags.tag) {
                .none => .none,
                .label => if (op.imm < 0)
                    .{ .inst = s.labels[@intCast(~op.imm)].backward.? }
                else for (&s.labels[@intCast(op.imm)].forward) |*label| {
                    if (label.*) |_| continue;
                    label.* = @intCast(s.cg.mir_instructions.len);
                    break .{ .inst = undefined };
                } else unreachable,
                .ref => switch (op.imm) {
                    else => unreachable,
                    0 => switch (op.flags.base.ref.valueOf(s)) {
                        .none, .unreach, .dead, .undef => unreachable,
                        .immediate => |imm| .{ .imm = switch (op.flags.base.size) {
                            .byte => if (std.math.cast(i8, @as(i64, @bitCast(imm)))) |simm| .s(simm) else .u(@as(u8, @intCast(imm))),
                            .word => if (std.math.cast(i16, @as(i64, @bitCast(imm)))) |simm| .s(simm) else .u(@as(u16, @intCast(imm))),
                            .dword => if (std.math.cast(i32, @as(i64, @bitCast(imm)))) |simm| .s(simm) else .u(@as(u32, @intCast(imm))),
                            .qword => if (std.math.cast(i32, @as(i64, @bitCast(imm)))) |simm| .s(simm) else .u(imm),
                            else => unreachable,
                        } },
                        .eflags => unreachable,
                        .register => |reg| .{ .reg = s.lowerReg(reg.toSize(op.flags.base.size, s.cg.target)) },
                        .register_pair, .register_triple, .register_quadruple, .register_offset, .register_overflow => unreachable,
                        .register_mask => |reg_mask| .{ .reg = s.lowerReg(reg_mask.reg.toSize(op.flags.base.size, s.cg.target)) },
                        .lea_nav => |nav| .{ .imm = .{ .nav = .{ .index = nav } } },
                        .lea_uav => |uav| .{ .imm = .{ .uav = uav } },
                        .lea_lazy_sym => |lazy_sym| .{ .imm = .{ .lazy_sym = lazy_sym } },
                        .lea_extern_func => |extern_func| .{ .imm = .{ .extern_func = extern_func } },
                        else => |mcv| .{ .mem = try mcv.mem(s.cg, .{ .size = op.flags.base.size }) },
                        .lea_frame, .elementwise_args, .reserved_frame, .air_ref => unreachable,
                    },
                    1...2 => |imm| switch (op.flags.base.ref.valueOf(s)) {
                        inline .register_pair, .register_triple, .register_quadruple => |regs| .{
                            .reg = s.lowerReg(regs[@intCast(imm - 1)].toSize(op.flags.base.size, s.cg.target)),
                        },
                        else => |mcv| .{ .mem = try mcv.mem(s.cg, .{
                            .size = op.flags.base.size,
                            .disp = @as(i32, @intCast(@divExact(op.flags.base.size.bitSize(s.cg.target), 8))) * (imm - 1),
                        }) },
                    },
                },
                .simm => .{ .imm = .s(op.adjustedImm(i32, s)) },
                .uimm => .{ .imm = .u(@bitCast(op.adjustedImm(i64, s))) },
                .lea => .{ .mem = try op.flags.base.ref.valueOf(s).deref().mem(s.cg, .{
                    .size = op.flags.base.size,
                    .index = switch (op.flags.index.ref.valueOf(s)) {
                        else => unreachable,
                        .none => .none,
                        .register => |index_reg| index_reg.toSize(.ptr, s.cg.target),
                    },
                    .scale = op.flags.index.scale,
                    .disp = op.adjustedImm(i32, s) + switch (op.flags.index.ref.valueOf(s)) {
                        else => unreachable,
                        .none, .register, .lea_nav, .lea_uav, .lea_lazy_sym, .lea_extern_func => 0,
                        .register_offset => |base_reg_off| base_reg_off.off,
                    },
                }) },
                .mem => .{ .mem = try op.flags.base.ref.valueOf(s).mem(s.cg, .{
                    .size = op.flags.base.size,
                    .index = switch (op.flags.index.ref.valueOf(s)) {
                        else => unreachable,
                        .none => .none,
                        .register => |index_reg| index_reg.toSize(.ptr, s.cg.target),
                    },
                    .scale = op.flags.index.scale,
                    .disp = op.adjustedImm(i32, s),
                }) },
            };
        }
    };
};
fn select(
    cg: *CodeGen,
    dst_temps: []Temp,
    dst_tys: []const Type,
    src_temps: []Temp,
    cases: []const Select.Case,
) Select.Error!void {
    @setEvalBranchQuota(33_500);
    cases: for (cases) |case| {
        switch (case.required_abi) {
            .any => {},
            .gnu => if (switch (cg.target.abi) {
                .none, .msvc, .itanium => cg.target.os.tag == .windows,
                else => false,
            }) continue :cases,
            .msvc => if (switch (cg.target.abi) {
                .none, .msvc, .itanium => cg.target.os.tag != .windows,
                else => true,
            }) continue :cases,
        }
        switch (case.required_cc_abi) {
            .any => {},
            .sysv64 => if (cg.target.cCallingConvention().? != .x86_64_sysv) continue :cases,
            .win64 => if (cg.target.cCallingConvention().? != .x86_64_win) continue :cases,
        }
        for (case.required_features) |required_feature| if (required_feature) |feature| if (!cg.hasFeature(feature)) continue :cases;
        for (case.src_constraints[0..src_temps.len], src_temps) |src_constraint, src_temp| if (!src_constraint.accepts(src_temp.typeOf(cg), cg)) continue :cases;
        for (case.dst_constraints[0..dst_temps.len], dst_tys) |dst_constraint, dst_ty| if (!dst_constraint.accepts(dst_ty, cg)) continue :cases;
        if (std.debug.runtime_safety) {
            for (case.src_constraints[src_temps.len..]) |src_constraint| assert(src_constraint == .any);
            for (case.dst_constraints[dst_temps.len..]) |dst_constraint| assert(dst_constraint == .any);
            for (case.dst_temps[dst_temps.len..]) |dst_temp| assert(dst_temp == .unused);
        }
        patterns: for (case.patterns) |pattern| {
            for (pattern.src[0..src_temps.len], src_temps) |src_pattern, src_temp| if (!src_pattern.matches(src_temp, cg)) continue :patterns;
            if (std.debug.runtime_safety) for (pattern.src[src_temps.len..]) |src_pattern| assert(src_pattern == .none);

            if (case.call_frame.alignment != .none) {
                const frame_allocs_slice = cg.frame_allocs.slice();
                const stack_frame_size =
                    &frame_allocs_slice.items(.abi_size)[@intFromEnum(FrameIndex.call_frame)];
                stack_frame_size.* = @max(stack_frame_size.*, switch (cg.target.cCallingConvention().?) {
                    .x86_64_sysv => case.call_frame.size,
                    .x86_64_win => win64_shadow_space + case.call_frame.size,
                    else => unreachable,
                });
                const stack_frame_align =
                    &frame_allocs_slice.items(.abi_align)[@intFromEnum(FrameIndex.call_frame)];
                stack_frame_align.* = stack_frame_align.max(case.call_frame.alignment);
            }

            var s: Select = .{
                .cg = cg,
                .temps = undefined,
                .types = undefined,
                .labels = @splat(.{ .forward = @splat(null), .backward = null }),
                .top = 0,
            };
            const s_tmp_types = s.types[@intFromEnum(Select.Operand.Ref.tmp0)..@intFromEnum(Select.Operand.Ref.dst0)];
            const s_tmp_temps = s.temps[@intFromEnum(Select.Operand.Ref.tmp0)..@intFromEnum(Select.Operand.Ref.dst0)];
            const s_dst_types = s.types[@intFromEnum(Select.Operand.Ref.dst0)..@intFromEnum(Select.Operand.Ref.src0)];
            const s_dst_temps = s.temps[@intFromEnum(Select.Operand.Ref.dst0)..@intFromEnum(Select.Operand.Ref.src0)];
            const s_src_types = s.types[@intFromEnum(Select.Operand.Ref.src0)..@intFromEnum(Select.Operand.Ref.none)];
            const s_src_temps = s.temps[@intFromEnum(Select.Operand.Ref.src0)..@intFromEnum(Select.Operand.Ref.none)];

            for (s_tmp_types, case.extra_temps) |*ty, spec| ty.* = spec.type;
            @memcpy(s_dst_types[0..dst_tys.len], dst_tys);
            for (s_src_types[0..src_temps.len], src_temps) |*ty, temp| ty.* = temp.typeOf(cg);
            std.mem.swap(Type, &s_src_types[pattern.commute[0]], &s_src_types[pattern.commute[1]]);

            caller_preserved: {
                const cc = switch (case.clobbers.caller_preserved) {
                    .none => break :caller_preserved,
                    .ccc => cg.target.cCallingConvention().?,
                    .zigcc => .auto,
                };
                assert(case.clobbers.eflags);
                const err_ret_trace_reg = if (cc == .auto and cg.pt.zcu.comp.config.any_error_tracing) err_ret_trace_reg: {
                    const param_gpr = abi.getCAbiIntParamRegs(.auto);
                    break :err_ret_trace_reg param_gpr[param_gpr.len - 1];
                } else .none;
                switch (cc) {
                    else => unreachable,
                    inline .x86_64_sysv, .x86_64_win, .auto => |_, tag| inline for (comptime abi.getCallerPreservedRegs(tag)) |reg| skip: {
                        if (reg == err_ret_trace_reg) break :skip;
                        const tracked_index = RegisterManager.indexOfKnownRegIntoTracked(reg) orelse break :skip;
                        try cg.register_manager.getRegIndex(tracked_index, null);
                        assert(cg.register_manager.lockRegIndexAssumeUnused(tracked_index).tracked_index == tracked_index);
                    },
                }
            }

            @memcpy(s_src_temps[0..src_temps.len], src_temps);
            std.mem.swap(Temp, &s_src_temps[pattern.commute[0]], &s_src_temps[pattern.commute[1]]);
            var dst_locks: [s_dst_temps.len][2]?RegisterLock = @splat(@splat(null));
            for (dst_locks[0..dst_temps.len], case.dst_temps[0..dst_temps.len]) |*dst_lock, dst_kind| dst_lock.* = try dst_kind.lock(cg);
            var tmp_locks: [s_tmp_temps.len][2]?RegisterLock = @splat(@splat(null));
            for (&tmp_locks, case.extra_temps) |*tmp_lock, tmp_spec| tmp_lock.* = try tmp_spec.kind.lock(cg);

            while (true) for (pattern.src[0..src_temps.len], src_temps) |src_pattern, *src_temp| {
                if (try src_pattern.convert(src_temp, cg)) break;
            } else break;
            var src_locks: [s_src_temps.len][2]?RegisterLock = @splat(@splat(null));
            for (src_locks[0..src_temps.len], src_temps) |*locks, src_temp| {
                const regs: [2]Register = switch (src_temp.tracking(cg).short) {
                    else => continue,
                    .register => |reg| .{ reg, .none },
                    .register_pair => |regs| regs,
                };
                for (regs, locks) |reg, *lock| {
                    if (reg == .none) continue;
                    lock.* = cg.register_manager.lockRegIndex(RegisterManager.indexOfRegIntoTracked(reg) orelse continue);
                }
            }
            @memcpy(s_src_temps[0..src_temps.len], src_temps);
            std.mem.swap(Temp, &s_src_temps[pattern.commute[0]], &s_src_temps[pattern.commute[1]]);

            if (case.clobbers.eflags) try cg.spillEflagsIfOccupied();

            var tmp_owned: [s_tmp_temps.len]bool = @splat(false);
            for (s_tmp_temps, &tmp_owned, case.extra_temps) |*temp, *owned, tmp_spec| temp.*, owned.* = try tmp_spec.create(&s);
            for (dst_temps, dst_tys, case.dst_temps[0..dst_temps.len]) |*dst_temp, dst_ty, tmp_kind| dst_temp.*, _ = try Select.TempSpec.create(.{ .type = dst_ty, .kind = tmp_kind }, &s);
            @memcpy(s_dst_temps[0..dst_temps.len], dst_temps);

            switch (case.each) {
                .once => |body| {
                    for (body) |inst| try s.emit(inst);
                    s.emitLabel(.@"0:");
                },
            }
            assert(s.top == 0);

            for (src_locks) |locks| for (locks) |lock| if (lock) |reg| cg.register_manager.unlockReg(reg);
            for (tmp_locks) |locks| for (locks) |lock| if (lock) |reg| cg.register_manager.unlockReg(reg);
            for (dst_locks) |locks| for (locks) |lock| if (lock) |reg| cg.register_manager.unlockReg(reg);
            caller_preserved: {
                const cc = switch (case.clobbers.caller_preserved) {
                    .none => break :caller_preserved,
                    .ccc => cg.target.cCallingConvention().?,
                    .zigcc => .auto,
                };
                const err_ret_trace_reg = if (cc == .auto and cg.pt.zcu.comp.config.any_error_tracing) err_ret_trace_reg: {
                    const param_gpr = abi.getCAbiIntParamRegs(.auto);
                    break :err_ret_trace_reg param_gpr[param_gpr.len - 1];
                } else .none;
                switch (cc) {
                    else => unreachable,
                    inline .x86_64_sysv, .x86_64_win, .auto => |_, tag| inline for (comptime abi.getCallerPreservedRegs(tag)) |reg| skip: {
                        if (reg == err_ret_trace_reg) break :skip;
                        cg.register_manager.unlockReg(.{ .tracked_index = RegisterManager.indexOfKnownRegIntoTracked(reg) orelse break :skip });
                    },
                }
            }
            for (tmp_owned, s_tmp_temps) |owned, temp| if (owned) try temp.die(cg);
            for (dst_tys, case.dst_temps[0..dst_temps.len], dst_temps) |dst_ty, dst_kind, *dst_temp| try Select.TempSpec.finish(.{ .type = dst_ty, .kind = dst_kind }, dst_temp, cg);
            return;
        }
    }
    return error.SelectFailed;
}